JAVA 循环请求头信息 java三种循环

转载

码海舵手之心 2023-06-15 20:32:28

文章标签 JAVA 循环请求头信息 java jvm 数据结构 System 文章分类 Java 后端开发

简介：

Java中有三种主要的循环结构：while循环，do…while循环和for循环。在Java5中还引入了一种主要用于数组的增强型for循环。本文主要是简单介绍循环的基本语法和适用场景。以及循环跳出或跳过的关键字。

while和do-while循环

while循环是最基本的循环，它的结构为：

while( 布尔表达式 ) {
  //循环内容
}

只要布尔表达式为true，循环就会一直执行下去。这种循环适用于循环次数不确定的情况，例如判断用户输入是否合法，或者读取文件内容直到结束等。

do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。它的结构为：

do {
  //代码语句
}while(布尔表达式);

先执行循环体，然后再判断布尔表达式的值。如果为true，则继续执行循环体，如果为false，则跳出循环。这种循环适用于至少需要执行一次的情况，例如显示菜单选项，或者计算阶乘等。

for循环和增强for循环

for循环是一种常用的循环，它的结构为：

for(初始化; 布尔表达式; 更新) {
  //代码语句
}

先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。执行一次循环后，更新循环控制变量。再次检测布尔表达式。循环执行上面的过程。这种循环适用于循环次数确定的情况，例如遍历数组或集合，或者计算累加和等。

增强型for循环是一种简化的for循环，主要用于数组或集合的遍历。它的结构为：

for(声明语句 : 表达式) {
  //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组或集合的方法。
这种循环适用于不需要知道索引值的情况，例如打印数组或集合中的所有元素等。

各循环的简单示例：

使用while循环判断一个数是否为素数：

public class Test {
  public static void main(String[] args) {
    int n = 17; //待判断的数
    boolean isPrime = true; //标志变量
    int i = 2; //从2开始除
    while(i < n) { //只需除到n-1即可
      if(n % i == 0) { //如果能整除，则不是素数
        isPrime = false;
        break; //跳出循环
      }
      i++; //增加除数
    }

使用do…while循环实现猜数字游戏：

public class Test {
  public static void main(String[] args) {
    int target = (int)(Math.random() * 100) + 1; //生成一个1到100的随机数
    int guess = 0; //用户猜的数
    Scanner input = new Scanner(System.in); //创建输入对象
    do {
      System.out.print("请输入一个1到100的整数：");
      guess = input.nextInt(); //获取用户输入
      if(guess < target) { //如果猜小了，提示大一点
        System.out.println("大一点");
      } else if(guess > target) { //如果猜大了，提示小一点
        System.out.println("小一点");
      }
    } while(guess != target); //直到猜中为止
    System.out.println("恭喜你，猜对了！"); //输出结果
  }
}

使用for循环打印九九乘法表：

public class Test {
  public static void main(String[] args) {
    for(int i = 1; i <= 9; i++) { //外层循环控制行数
      for(int j = 1; j <= i; j++) { //内层循环控制列数
        System.out.print(j + "x" + i + "=" + (i * j) + "\t"); //打印每个单元格的内容，\t表示制表符
      }
      System.out.println(); //换行
    }
  }
}

使用增强型for循环统计数组中的最大值和最小值：

public class Test {
  public static void main(String[] args) {
    int[] arr = {12, 34, 56, 78, 90}; //定义一个数组
    int max = arr[0]; //假设第一个元素为最大值
    int min = arr[0]; //假设第一个元素为最小值
    for(int num : arr) { //遍历数组中的每个元素
      if(num > max) { //如果元素大于当前最大值，更新最大值
        max = num;
      }
      if(num < min) { //如果元素小于当前最小值，更新最小值
        min = num;
      }
    }
    System.out.println("数组中的最大值是：" + max); //输出结果
    System.out.println("数组中的最小值是：" + min);
  }
}

关键字break和continue

当然我们会想，如何在循环进行时中止掉它呢，换言之如何跳出循环或者跳过某一次循环呢？

break

break关键字用于跳出当前循环或者switch语句，继续执行后面的语句。它通常用于终止循环，或者跳出不需要执行的分支。例如，当我们在循环中找到了想要的结果，就可以用break语句结束循环，避免不必要的计算。或者，当我们在switch语句中匹配到了对应的case，就可以用break语句跳出switch语句，避免执行其他case。

public class Test {
  public static void main(String[] args) {
    for(int i = 1; i <= 10; i++) { //循环10次
      if(i == 5) { //当i等于5时，跳出循环
        break;
      }
      System.out.println("i = " + i); //打印i的值
    }
    System.out.println("循环结束"); //输出结果
  }
}

输出结果为：

i = 1
i = 2
i = 3
i = 4
循环结束

continue

continue关键字用于跳过当前循环的剩余部分，直接进入下一次循环。它通常用于忽略某些不符合条件的情况，或者提前结束本次循环。
例如，当我们在循环中遇到了某些无效的数据，就可以用continue语句跳过本次循环，继续处理下一个数据。或者，当我们在循环中已经完成了本次循环的主要任务，就可以用continue语句提前结束本次循环，节省时间。

public class Test {
  public static void main(String[] args) {
    for(int i = 1; i <= 10; i++) { //循环10次
      if(i % 2 == 0) { //如果i是偶数，跳过本次循环
        continue;
      }
      System.out.println("i = " + i); //打印i的值
    }
    System.out.println("循环结束"); //输出结果
  }
}

输出结果为：

i = 1
i = 3
i = 5
i = 7
i = 9
循环结束

补充

switch语句

switch语句是一种多分支的选择结构，它根据一个表达式的值，选择执行相应的分支。它的形式和用法如下：

switch语句的语法格式为：

switch(表达式) {
  case 值1:
    //执行语句
    break; //可选
  case 值2:
    //执行语句
    break; //可选
  //你可以有任意数量的case语句
  default: //可选
    //执行语句
}

switch语句的执行流程为：

首先计算表达式的值，表达式可以是byte，short，char，int，String或者枚举类型。
然后与每个case后面的值进行比较，如果相同，则执行对应的语句块。
如果没有匹配到任何case，且有default分支，则执行default分支的语句块。
如果有break语句，则跳出switch语句，继续执行后面的语句。如果没有break语句，则会继续执行下一个case或者default分支，直到遇到break或者switch语句结束。

基础switch示例：

public class Test {
  public static void main(String[] args) {
    int week = 3; //定义一个星期变量
    String day; //定义一个星期几变量
    switch(week) { //根据星期判断星期几
      case 1:
        day = "星期一";
        break;
      case 2:
        day = "星期二";
        break;
      case 3:
        day = "星期三";
        break;
      case 4:
        day = "星期四";
        break;
      case 5:
        day = "星期五";
        break;
      case 6:
        day = "星期六";
        break;
      case 7:
        day = "星期日";
        break;
      default: //如果星期不在1到7之间，输出错误信息
        day = "错误的星期";
    }
    System.out.println("今天是" + day); //输出结果
  }
}

输出结果为：

今天是星期三

在java12上switch又出现了新的特性，主要包括：

switch表达式：switch语句可以作为一个表达式，有自己的返回值，可以用于赋值或其他操作。
箭头符号：switch语句可以使用 -> 符号来连接条件和动作，这样可以省略break语句，避免fall-through的问题。
多条件匹配：switch语句可以使用逗号来分隔多个条件，表示它们对应相同的动作。
yield关键字：switch语句可以使用yield关键字来返回一个值，这样可以在代码块中执行一些逻辑后再返回。

java12新特性示例：

使用switch表达式根据月份判断季节：

public class Test {
  public static void main(String[] args) {
    int month = 8; //定义一个月份变量
    String season = switch (month) { //使用switch表达式赋值给season变量
      case 12, 1, 2 -> "冬季"; //使用逗号分隔多个条件
      case 3, 4, 5 -> "春季";
      case 6, 7, 8 -> "夏季";
      case 9, 10, 11 -> "秋季";
      default -> "错误的月份"; //使用default处理其他情况
    };
    System.out.println(month + "月是" + season); //输出结果
  }
}

输出结果为：

8月是夏季

使用switch表达式根据星期判断是否工作日：

public class Test {
  public static void main(String[] args) {
    int week = 3; //定义一个星期变量
    boolean isWorkday = switch (week) { //使用switch表达式赋值给isWorkday变量
      case 1, 2, 3, 4, 5 -> true; //使用箭头符号连接条件和动作
      case 6, 7 -> false;
      default -> throw new IllegalArgumentException("错误的星期"); //使用throw语句抛出异常
    };
    System.out.println("今天是" + (isWorkday ? "工作日" : "休息日")); //（三元表达式）输出结果
  }
}

输出结果为：

今天是工作日

使用switch表达式根据数字转换为英文单词：

public class Test {
  public static void main(String[] args) {
    int num = 3; //定义一个数字变量
    String word = switch (num) { //使用switch表达式赋值给word变量
      case 1 -> "One";
      case 2 -> "Two";
      default -> { //使用代码块处理复杂逻辑
        String result = String.format("Other (%d)", num);
        yield result; //使用yield关键字返回值
      }
    };
    System.out.println("The word is " + word); //输出结果
  }
}

输出结果为：

The word is Three

三元表达式

三元表达式是一种简洁的条件运算符，它根据一个布尔表达式的值，返回两个表达式中的一个结果。

三元表达式的语法格式为：

条件表达式 ? 表达式1 : 表达式2

三元表达式的执行流程为：
首先计算条件表达式的值，条件表达式必须是一个布尔类型的值，即true或false。
然后根据条件表达式的值，选择执行表达式1或表达式2，并返回其结果。
只会执行表达式1或表达式2中的一个，不会同时执行两个。

Tips:

标签必须在循环语句之前使用，且不能有其他语句在标签和循环之间。
标签只能和break或continue一起使用，不能单独使用或和goto一起使用。
标签可以用于任何循环语句，如for，while，do-while等。
标签的作用域是从定义处到所在方法的结束处。

示例：

使用标签跳出两层循环：

public class Test {
  public static void main(String[] args) {
    outer: //定义一个标签
    for (int i = 1; i <= 3; i++) { //外层循环
      for (int j = 1; j <= 3; j++) { //内层循环
        System.out.println("i = " + i + ", j = " + j);
        if (i == 2 && j == 2) { //满足条件时
          break outer; //跳出带有标签的循环
        }
      }
    }
    System.out.println("End");
  }
}

输出结果为：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 2, j = 2
End

使用标签跳过当前循环的剩余部分，并进入下一次带有标签的循环：

public class Test {
  public static void main(String[] args) {
    outer: //定义一个标签
    for (int i = 1; i <= 3; i++) { //外层循环
      for (int j = 1; j <= 3; j++) { //内层循环
        System.out.println("i = " + i + ", j = " + j);
        if (i == 2 && j == 2) { //满足条件时
          continue outer; //跳过当前循环，并进入下一次带有标签的循环
        }
      }
    }
    System.out.println("End");
  }
}

输出结果为：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 2, j = 2
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3
End

如果你有任何意见或建议，请在评论区留言，我会尽快回复。
最后，祝你今天心情愉快，明天更美好！

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：java拷贝构造函数的语法拷贝构造函数调用

下一篇：jquery data-id 取值 jquery如何获取id的值

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯