首页 > 编程笔记 > Java笔记 阅读：198

Java break和continue的用法

通义灵码
break 关键字可以用在 for、while、do while 循环语句中，功能是跳出整个语句块，结束当前循环的执行。当然，break 语句也可用在 switch 语句中。

在循环体中使用 break 语句有两种方式：带标签和不带标签。break 语句的语法格式如下：
break;         // 不带标签
break label;   // 带标签，label 是标签名
不带标签的 break 语句使程序跳出所在层的循环体，而带标签的 break 语句使程序跳出标签指示的循环体。

【实例1】不带标签的 break 语句的用法。 
  1. import static java.lang.Math.sqrt; 
  2.  
  3. public class Test {  
  4.     public static void main(String[] args) { 
  5.         // 输出100以内的所有素数 
  6.         int i; 
  7.         int j; 
  8.         int c = 0; 
  9.         //注释①
  10.         for (i = 2; i <= 100; i++) {
  11.             for (j = 2; j <= sqrt(i); j++) {
  12.                 //注释② 
  13.                 if (i % j == 0) { 
  14.                     break; 
  15.                 } 
  16.             } 
  17.  
  18.             if (j > sqrt(i)) { 
  19.                 System.out.printf("%5d", i); // 修正了这里的n%5dn为%5d 
  20.                 c++; // 修正了这里的C + +为c++ 
  21.  
  22.                 if (c % 5 == 0) { 
  23.                     System.out.println(); // 换行 
  24.                 } 
  25.             } 
  26.         } 
  27.     } 
  28. }
运行结果为： 
    2    3    5    7   11
   13   17   19   23   29
   31   37   41   43   47
   53   59   61   67   71
   73   79   83   89   97
在上面的程序中，当条件 i%j==0 为 true 时，执行 break 语句，结束注释 ② 处的内层循环，返回注释 ① 处的外层循环中继续执行下一次循环。

【实例2】 带标签的 break 语句的用法。 
  1. public class Test {  
  2.     public static void main(String[] args) { 
  3.         // 添加了标签label 
  4.         label: for (int i = 0; i < 5; i++) { 
  5.             for (int j = 3; j > 0; j--) { 
  6.                 System.out.println("i的值：" + i + ", j的值：" + j); 
  7.                 if (i == j) { 
  8.                     break label;
  9.                 } 
  10.             }
  11.         }
  12.     }
  13. }
运行结果为：

i的值：0, j的值：3
i的值：0, j的值：2
i的值：0, j的值：1
i的值：1, j的值：3
i的值：1, j的值：2
i的值：1, j的值：1

上述代码中的 break 语句的后面指定了 label 标签，当条件满足 i==j 时，执行 break 语句，程序就会跳出 label 标签所指定的循环，即外层循环，所以最后输出的是“i的值：1，j的值：1”。

continue语句

continue 语句用来结束本次循环，跳过循环体中尚未执行的语句，接着进行终止条件的判断，以决定是否继续循环。

在循环体中使用continue语句有两种方式：带标签和不带标签。continue 语句的语法格式如下： 
continue;
continue label;

【实例 3】不带标签的 continue 语句的用法。 
  1. public class Test { 
  2.     public static void main(String[] args) { 
  3.         int[] a = new int[10]; // 数组a用来存储被删除的数（以3结尾或3的倍数） 
  4.         int c = 0; // 计数器，记录被删除数的个数 
  5.  
  6.         for (int i = 1; i <= 20; i++) { 
  7.             // 如果i是3的倍数或者以3结尾 
  8.             if (i % 3 == 0 || i % 10 == 3) { 
  9.                 // 将满足条件的数（即被删除的数）放入数组a中 
  10.                 a[c] = i; 
  11.                 // 计数器加1 
  12.                 c++; 
  13.                 // 跳过后续打印语句，直接开始下一次循环 
  14.                 continue; 
  15.             } 
  16.             // 输出不满足条件的数（即保留的数） 
  17.             System.out.print(i + " "); 
  18.         } 
  19.  
  20.         System.out.println(); // 换行 
  21.  
  22.         // 输出被删除的数 
  23.         System.out.print("被删除的数为: "); 
  24.         for (int j = 0; j < c; j++) { 
  25.             System.out.print(a[j] + " "); 
  26.         } 
  27.  
  28.         System.out.println(); // 换行 
  29.     } 
  30. }
运行结果为：

1 2 4 5 7 8 10 11 14 16 17 19 20
被删除的数为: 3 6 9 12 13 15 18


【实例 4】带标签的 continue 语句的用法。 
  1. public class Test { 
  2.     public static void main(String[] args) { 
  3.         int[][] matrix = { 
  4.             {1, 2, 3}, 
  5.             {4, 5, 6}, 
  6.             {7, 8, 9}, 
  7.             {10, 11, 12} 
  8.         }; 
  9.  
  10.         int targetValue = 5; // 要查找的目标值 
  11.         int i,j;
  12.         // 外层循环遍历矩阵的行，标签为outerLoop 
  13.         outerLoop: for (i = 0; i < matrix.length; i++) { 
  14.             // 内层循环遍历当前行的列 
  15.             for (j = 0; j < matrix[i].length; j++) { 
  16.                 // 如果找到目标值，则使用带标签的continue跳过当前行的剩余部分 
  17.                 if (matrix[i][j] == targetValue) { 
  18.                     System.out.println("Found " + targetValue + " in row " + (i + 1) + ", skipping rest of the row."); 
  19.                     continue outerLoop; // 跳转到outerLoop标签处，即外层循环的下一次迭代 
  20.                 } 
  21.                 // 打印当前元素（非目标值） 
  22.                 System.out.print(matrix[i][j] + " "); 
  23.             } 
  24.             System.out.println();  
  25.         } 
  26.     } 
  27. }
程序中用带标签的 continue 语句来处理一个二维数组，当找到目标值 5 时，会跳过当前行的剩余部分并继续处理下一行。

程序的执行结果为：

1 2 3
4 Found 5 in row 2, skipping rest of the row.
7 8 9
10 11 12

相关文章