Java的循环语句

foreach 循环语句

foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。

foreach 循环语句的语法格式如下：

for(类型 变量名:集合) { 语句块; }

其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。每执行一次循环语句，循环变量就读取集合中的一个元素，其执行流程。

如图 1 所示。

例 1

假设有一个数组，采用 for 语句遍历数组的方式如下：

// 声明并初始化数组

int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };

System.out.println("----for----");

// for 语句

for (int i = 0; i < numbers.length; i++) {

 System.out.println("Count is:" + numbers[i]);

}

上述第 2 行语句声明并初始化了 7 个元素数组集合，目前大家只需要知道当初始化数组时，要把相同类型的元素放到 {…} 中并且用逗号分隔（,）即可。

关于数组集合会在教程后面详细介绍，这里我们只需要大概了解就可以。numbers.length

是获得数组的长度，length 是数组的属性，numbers[i] 是通过数组下标访问数组元素。

那么采用 for-each 循环语句遍历数组的方式如下：

// 声明并初始化 int 数组

int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };

System.out.println("----for each----");

// for-each 语句

for (int item : numbers) {

 System.out.println("Count is:" + item);

}

从示例中可以发现，item 不是循环变量，它保存了集合中的元素，for-each 语句将集合中的元素一一取出来，并保存到 item 中，这个过程中不需要使用循环变量，通过数组下标访问数组中的元素。可见 for-each 语句在遍历集合的时候要简单方便得多。

使用 break 语句直接强行退出循环（break）

可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。

在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。

break 语句能用于任何 Java 循环中，包括人们有意设置的无限循环。在一系列嵌套循环中

使用 break 语句时，它将仅仅终止最里面的循环。例如：

public static void main(String[] args) {

 // 外循环，循环 5 次

 for (int i = 0; i < 5; i++) {

 System.out.print("第" + (i + 1) + "次循环：");

 // 内循环，设计为循环 10 次

 for (int j = 0; j < 10; j++) {

 // 判断 j 是否等于 3，如果是，则终止循环

 if (j == 3) {

 break;

}

 System.out.print("内循环的第" + (j + 1) + "次循环\t");

 }

 System.out.println();

 }

}

该程序运行结果如下所示：

第 1 次循环：内循环的第 1 次循环 内循环的第 2 次循环 内循环的第 3 次循环 第 2 次循环：内循环的第 1 次循环 内循环的第 2 次循环 内循环的第 3 次循环 第 3 次循环：内循环的第 1 次循环 内循环的第 2 次循环 内循环的第 3 次循环 第 4 次循环：内循环的第 1 次循环内循环的第 2 次循环 内循环的第 3 次循环 第 5 次循环：内循环的第 1 次循环 内循环的第2 次循环 内循环的第 3 次循环

从程序运行结果来看，在内部循环中的 break 语句仅仅终止了所在的内部循环，外部循环

没有受到任何的影响。

注意：一个循环中可以有一个以上的 break 语句，但是过多的 break 语句会破坏代码结构。

switch 循环语句中的 break 仅影响 switch 语句，不会影响循环。

嵌套循环

嵌套循环既可以是 for 循环嵌套 while 循环，也可以是 while 循环嵌套 do-while 循环 …… 即各种类型的循环都可以作为外层循环，也可以作为内层循环。

当程序遇到嵌套循环时，如果外层循环的循环条件允许，则开始执行外层循环的循环体，

而内层循环将被外层循环的循环体来执行——只是内层循环需要反复执行自己的循环体而

已。

当内层循环执行结束，且外层循环的循环体执行结束时，则再次计算外层循环的循环条件

，决定是否再次开始执行外层循环的循环体。

根据上面分析，假设外层循环的循环次数为 n 次，内层循环的循环次数为 m 次，那么内层循环的循环体实际上需要执行 n×m 次。嵌套循环的执行流程如图 1 所示。

图 1 嵌套循环的执行流程

从图 1 来看，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条

件为 false 时，才会完全跳出内层循环，才可以结束外层循环的当次循环，开始下一次循

环。下面是一个使用嵌套循环输出九九乘法表实例。

public static void main(String[] args) {

 System.out.println("乘法口诀表：");

 // 外层循环

 for (int i = 1; i <= 9; i++) {

 // 内层循环

 for (int j = 1; j <= i; j++) {

 System.out.print(j + "*" + i + "=" + j * i + "\t");

 }

 System.out.println();

 }

}

运行上面程序，看到如下运行结果:

乘法口诀表：

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

从上面运行结果可以看出，进入嵌套循环时，循环变量 i 开始为 1，这时即进入了外层循

环。进入外层循环后，内层循环把 i 当成一个普通变量，其值为 0。在外层循环的当次循

环

continue 循环语句

continue 语句是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，接着进行下一次是否执行循环的判定。

continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。

简单来讲，continue 是忽略循环语句的当次循环。

注意：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。

在循环体中使用 continue。语法格式如下：

continue

下面看一个示例，代码如下：

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

for (int i = 0; i < numbers.length; i++) {

 if (i == 3) {

 continue;

 }

 System.out.println("Count is: " + i);

}

在上述程序代码中，当条件 i==3 的时候执行 continue 语句，continue 语句会终止本次循环，循环体中 continue 之后的语句将不再执行，接着进行下次循环，所以输出结果中没有 3。程序运行结果如下：

Count is: 0

Count is: 1

Count is: 2

Count is: 4

Count is: 5

Count is: 6

Count is: 7

Count is: 8

Count is: 9

 

如果 main 方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在

前面的代码先执行，排在后面的代码后执行。

这意味着：如果没有流程控制，JAVA 方法里的语句是一个顺序执行流，从上向下依次执

行每条语句。

Java 同样提供了这两种流程控制结构的语法，Java 提供了 if 和 switch 两种分支语句，并提供了 while、do while 和 for 三种循环语句。

一般写循环语句时，分以下三步走：

定义初始值

设置判断条件

初始值变化

除此之外，JDK5 还提供了一种新的循环：foreach 循环，能以更简单的方式来遍历集合、

数组的元素。

Java 还提供了 break、continue 和 return 来控制程序的循环结构，作用如下：

break：表示跳出当前层循环

continue：表示跳出本次循环，进入下一次循环

return：跳出当前方法的循环

当在实现某个功能语句时，如果需要通过某一个条件去判断，则用选择结构。当实现某个

功能需要通过循环去实现，则用循环结构。当然循环和选择是可以相互嵌套的。