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

Java中的break和continue（非常详细）

break和continue是 Java 语言中提供的跳转语句，可以控制程序从一个地方直接跳转到另外一个地方继续执行，在循环体比较复杂的情况下经常会被用到。

Java break语句

在分支语句的学习中，大家已经接触过 break 语句，可以用它来结束 switch 分支语句的继续执行。除此之外，break 还有两种用法，一种是在循环体中强制退出循环，另一种是配合标签使用实现类似 C语言 goto 语句的效果。

1) 使用break强制退出循环

在程序中，有时需要强行终止循环，而不是等到循环条件为 false 时才退出循环。此时，可以使用 break 语句来实现这种功能。

break 语句可以出现在循环体中，其作用是使程序立即退出循环，转而执行该循环外的语句。如果 break 语句出现在嵌套循环的内层循环中，则只会终止当前内层循环，外层循环则不受影响。

break 语句在 3 种循环语句中都可以使用，书写在其重复执行语句块中，一般配合 if 语句进行使用，执行流程如下图所示：


图 1 break控制循环流程图

【实例】用 while 循环语句来循环输入并打印学生成绩，如果输入成绩为 -1 则退出循环。 
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("-------输入学生成绩-------");
            double score = scanner.nextDouble();
            if (score < 0) {
                break;
            }
            System.out.println("学生成绩为：" + score);
        }
        System.out.println("循环终止！");
    }
}
程序的运行结果如下：

-------输入学生成绩------
90
学生成绩为：90.0
-------输入学生成绩------
-1
循环终止！

程序中，第 6~13 行为一个 while 循环语句，其中 while(true) 即循环条件的结果一直都是 true，循环将会一直执行，这也就是所谓的死循环。

第 9 行书写了一个 if 条件语句：
break 语句不仅可以在 while 循环中使用，也可以在 do-while、for 循环中使用，方式相同，都是书写在循环体中，碰到 break 则循环终止。

2) break语句配合标签

break 语句并不局限于终止一个循环语句或者退出 switch 分支语句，它还可以配合标签使用，用来终止一个或任意多个代码块，通过它可以实现代码跳转到指定位置继续执行。

标签的命名需要遵循标识符的命名规则，标签名后书写一个冒号，冒号后为标签中要执行的代码块，该代码块中可以使用“break 标签名”来退出该代码块，具体语法如下：
标签名1: {
    代码块1中的语句…
    if (跳转条件) { // 一般需要配合if使用，否则break后不可以书写代码
        break 标签名1;  // 执行到break语句时，将结束该代码块，执行代码块后的代码
    }
    代码块中1的语句…
}
代码块后的代码…
接下来，编写一个简单的案例来演示 break 配合标签使用的语法。 
public class Demo {
    public static void main(String[] args) {
        labelName: {
            int i = 1;
            System.out.println("代码块语句1");
            if (i == 1) {    // 此为跳转条件，一般break都配合if使用
                break labelName;
            }
            System.out.println("代码块语句2");
        }
        System.out.println("代码块后的代码");
    }
}
程序的运行结果如下：

代码块语句1
代码块后的代码

程序中，第 3 行的 labelName 是标签名，相当于给后边 { } 中的代码块起了一个名字。

第 4 行声明了一个变量 i，初始值为 1，作为终止代码块的条件。第 6 行是一个判断条件，i 的初始值为 1，因此 1 == 1 这个条件成立，执行 if 后的 break 语句，break 后跟的是刚才的标签名，表示跳出以 labelName 命名的代码块，此时第 9 行的语句将不再执行，直接跳转到 labelName 标签对应的代码块后继续执行，也就是执行第 11 行语句。

程序中使用{}将一句或多句代码括起来即可组成一个代码块，这个代码块并不一定是在分支后或者循环后，可以独立存在。

在此需要注意的是，标签定义的代码块中有可能仍然有标签定义，即代码块是可以进行嵌套的，此时如果 break 在外层标签的代码块中，那么其后的标签名只能书写外层的标签名，如果 break 在内层中则可以书写内层标签名也可书写外层的标签名，即 break 后的标签名只要是包住自己的标签即可。具体语法如下： 
标签名1: {
    代码块1中的语句…
    if (跳转条件) { // 一般需要配合if使用，否则break后不可以书写代码
        break 标签名1; // 执行到break语句时，将结束该代码块，执行代码块后的代码
    }
    标签名2: {
        代码块2中的语句1
        if (跳转条件) {
            break 标签名1/标签名2;
        }
        代码块2中的语句2
    }
    代码块中1的语句…
}
代码块后的代码…
在标签 2 中包含的 break 语句，如果跟的是标签名 2 则终止标签名 2 对应的代码块，继续执行代码块 1 中的后续代码，如果跟的是标签名 1 则直接退出标签名 1 对应的代码块，继续执行代码块后的代码。

此处语法仅仅是两层嵌套，实际可以是很多层，含义与此一样，只要是包住该 break 语句的标签名都可以使用。即 break 配合标签使用，可以用来终止一个或任意多个代码块。利用 break 配合标签使用，可以用来直接终止多层循环的运行。

接下来，编写一个 3 层嵌套 for 循环，循环变量分别为 x、y、z，如果 x + y + z = 10，则直接终止所有循环。 
public class Demo {
    public static void main(String[] args) {
        int x = 1, y = 1, z = 1;
        labelX: for (x = 1; x < 100; x++) {
            labelY: for (y = 1; y < 100; y++) {
                labelZ: for (z = 1; z < 100; z++) {
                    if (x + y + z == 10) {
                        break labelX;
                    }
                }
            }
        }
        System.out.println("退出循环时x为：" + x);
        System.out.println("退出循环时y为：" + y);
        System.out.println("退出循环时z为：" + z);
    }
}
程序的运行结果如下：

退出循环时x为：1
退出循环时y为：1
退出循环时z为：8

程序中，第 4 行 labelX 是第 1 层循环的标签，labelX 后正常应该是{ }括起来的代码块，但是该代码是一个 for 循环，是一个整体，除此之外没有其他代码，因此可以省略{ }。

第 5 行 labelY 是第 2 层循环的标签。第 6 行 labelZ 是第 3 层循环的标签。

第 7 行是一个判断条件，如果 x + y + z 的结果为 10 则执行第 8 行代码。该程序执行过程中，此时 x = 1，进入第 1 层循环体，第 1 层的循环体是第 2 层循环；此时 y = 1，进入第 2 层循环的循环体，第 2 层的循环体是第 3 层循环；当第 3 层循环到 z = 8 时，判断条件成立，此时 x = 1、y = 1、z = 8，执行第 8 行语句，直接退出 labelX 对应的循环，即第 1 层循环。

因此，此时 z++、y++、x++ 都不会执行，将直接退出 3 层循环，转而开始执行第 13 行代码。

Java continue语句

continue 语句与 break 语句类似，都有两种用法，可以在循环体中直接使用，也可以配合标签使用。

和 break 语句不同的是，continue 在循环体中直接使用，用来结束本次循环直接进入下一次循环，配合标签使用则用来实现类似 C语言 goto 语句的效果，实现向前跳转。同时，需要注意 continue 只能用在循环体中。

1) 使用continue退出当前循环

continue 语句在循环体中直接使用可跳出本次循环体，本次循环体中剩余的语句将不再执行，直接进入下一次循环。换句话说，continue 语句可以结束本次循环，跳到循环条件处判断是否进入下一次循环。

continue 语句可以出现在 while 循环、do-while 循环以及 for 循环的循环体中，一般配合 if 语句进行使用，执行流程如下图所示：


图 2 continue控制循环流程图

从图 2 可以看出，程序碰到 continue 语句时，之后的语句组 2 将不再执行，直接回到循环条件处进行判断，根据判断结果来决定是否进入下一次循环。

continue 语句类似 break 语句，两者的区别在于：continue 并不是中断整个循环，而是终止当前这一次，进入下一次循环，并且 continue 只能出现在循环体中；break 语句出现在循环体中是终止整个循环，也可以出现在 switch 语句中。

接下来，根据 continue 的特性，编写一个案例：循环遍历 1~10 之间的偶数，4 不要打印出来。 
public class Demo {
    public static void main(String[] args) {
        System.out.println("-------循环遍历1~10的偶数，4不要打印出来------");
        for (int i = 1; i <= 10; i++) {
            if (i % 2 != 0) {
                continue;
            }
            if (i == 4) {
                continue;
            }
            System.out.print(i + "\t");
        }
    }
}
程序的运行结果如下： 
-------循环遍历1~10的偶数，4不要打印出来------
2　　6　　8　　 10
程序中，第 5 行是一个判断条件，如果 i 不是偶数，将执行 continue 语句，即终止本次循环，继续下一次循环。意味着在 i 不是偶数的情况下，第 8~11 行将不执行，直接执行 i++，然后进行 i <= 10 判断，如果条件成立则进入下一次循环，否则退出循环。

第 8 行同样是一个判断条件，如果 i 的值为 4，则执行 continue 语句，即第 11 行不执行，直接执行 i++，然后进行循环条件判断，如果成立则进入下一次循环，否则退出循环。如果 i 是偶数，并且 i 不等于 4，将执行第 11 行，即将其输出。

continue 语句不仅可以在 for 循环中使用，也可以在 do-while、while 循环中使用，方式相同，都是书写在循环体中，碰到 continue 语句将终止本次循环，进入下一次循环。

2) continue语句配合标签

continue 语句可以配合标签使用，该标签必须是为循环指定的名字，不能是普通代码块。当程序执行到 continue 语句后，会回到标记的所在位置继续指定循环的下一次循环。

与 break 类似，continue 所处的循环也可以是嵌套的，continue 后所书写的标签名可以是当前循环的标签名，也可以是外层循环的标签名。

continue 语句可以出现在 while、do-while 以及 for 循环中用来控制语句的跳转，在此以 for 循环为例进行语法的说明，具体语法如下： 
标签名1:for(;;) {
　　循环1中的语句…
　　标签名2:for(;;) {
　　　　循环2中的语句1
　　　　if (跳转条件) {
　　　　　　continue 标签名1/标签名2;
　　　　}
　　　　循环2中的语句2
　　}
　　循环1中的语句…
}
循环后的代码…
在此，continue 如果跟的是标签名 2，则跳转到标签 2 对应的循环，即中止循环 2 的当前循环，进入下一次循环，与直接使用 continue 结果一样；如果跟的是标签 1，则跳转到标签 1 对应的循环，直接结束外层循环的当前循环（循环 1 中嵌套的循环将直接终止），进入外层循环的下一次循环。此处语法仅仅是两层嵌套循环，实际可以是很多层，含义与此一样。

接下来，利用 continue 配合标签使用实现九九乘法表。 
public class Demo {
    public static void main(String[] args) {
        System.out.println("-------九九乘法表-------");
        a: for (int i = 1; i <= 9; i++) {
            b: for (int j = 1; j <= 10; j++) {
                System.out.print(j + "*" + i + "=" + i * j + "\t");
                if (i == j) {
                    System.out.println();
                    continue a;
                }
            }
        }
    }
}
程序的运行结果如下：

-------九九乘法表------
1*1=1
1*2=2　　 2*2=4
1*3=3　　 2*3=6　　  3*3=9
1*4=4　　 2*4=8　　  3*4=12  4*4=16
1*5=5　　 2*5=10　　 3*5=15  4*5=20  5*5=25
1*6=6　　 2*6=12　　 3*6=18  4*6=24  5*6=30  6*6=36
1*7=7　　 2*7=14　　 3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
1*8=8　　 2*8=16　　 3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
1*9=9　　 2*9=18　　 3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

程序中，第 4 行的 a 是外层循环的标签。第 5 行的 b 是内层循环的标签。

内层循环条件是 j <= 10，即从内层循环来看它应该循环 10 次。第 7 行是一个判断，如果 j 和 i 的值相等，则执行第 8 行和第 9 行语句。第 9 行意味着继续 a 标签对应的循环，即外层循环，执行该语句将结束内层循环，直接进行外层循环的 i++，然后进行外层循环的循环条件判断，如果条件成立则进入外层循环的下一次循环。

从结果很明显可以看出，内层循环并没有执行 10 次，而是到达 i == j 时就终止了，进入了外层循环的下一次循环。

相关文章