四、（续）流程控制--while for

一、while

循环是程序中的重要流程结构之一。循环语句能够使程序代码重复执行，适用于需要重复一段代码直到满足特定条件为止的情况。

所有流行的编程语言中都有循环语句。Java 中采用的循环语句与C语言中的循环语句相似，主要有 while、do-while 和 for。另外 Java 5 之后推出了 for-each 循环语句，for-each 循环是 for 循环的变形，它是专门为集合遍历而设计的。for-each 并不是一个关键字。

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体。当反复执行这个循环体时，需要在合适的时候把循环条件改为假，从而结束循环，否则循环将一直执行下去，形成死循环。

循环语句可能包含如下 4 个部分。

• 初始化语句（init statement）： 一条或多条语句，这些语句用于完成一些初始化工作，初始化语句在循环开始之前执行。
• 循环条件（test_expression）：这是一个 boolean 表达式，这个表达式能决定是否执行循环体。
• 循环体（body_statement）：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行。如果这个代码块只有一行语句，则这个代码块的花括号是可以省略的。
• 迭代语句（iteration_statement）：这个部分在一次循环体执行结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量，使得循环在合适的时候结束。

上面 4 个部分只是一般性的分类，并不是每个循环中都非常清晰地分出了这 4 个部分

while 语句

while 语句是 Java 最基本的循环语句，是一种先判断的循环结构，可以在一定条件下重复执行一段代码。该语句需要判断一个测试条件，如果该条件为真，则执行循环语句（循环语句可以是一条或多条），否则跳出循环。

while 循环语句的语法结构如下：

while(条件表达式) {
    语句块;
}

其中语句块中的代码可以是一条或者多条语句，而条件表达式是一个有效的 boolean 表达式，它决定了是否执行循环体。当条件表达式的值为 true 时，就执行大括号中的语句块。

执行完毕，再次检查表达式是否为 true，如果还为 true，则再次执行大括号中的代码，否则就跳出循环，执行 while 循环之后的代码。图 1 表示了 while 循环语句的执行流程。

例 子

使用 while 语句计算 10 的阶乘，其具体代码如下所示。

public static void main(String[] args) {
    int i = 1;
    int n = 1;
    while(i <= 10) {
        n=n*i;
        i++;
    }
    System.out.println("10的阶乘结果为："+n);
}

在上述代码中，定义了两个变量 i 和 n，循环每执行一次 i 值就加 1，判断 i 的值是否小于等于 10，并利用 n=n*i 语句来实现阶乘。当 i 的值大于 10 之后，循环便不再执行并退出循环。

运行程序，执行的结果如下所示：

10 的阶乘结果为：3628800

do-while 语句

如你刚才所见，如果 while 循环一开始条件表达式就是假的，那么循环体就根本不被执行。然而，有时需要在开始时条件表达式即使是假的情况下，while 循环至少也要执行一次。换句话说，有时你需要在一次循环结束后再测试中止表达式，而不是在循环开始时。

幸运的是，Java就提供了这样的循环：do-while循环。do-while 循环语句也是 Java 中运用广泛的循环语句，它由循环条件和循环体组成，但它与 while 语句略有不同。do-while 循环语句的特点是先执行循环体，然后判断循环条件是否成立。

do-while 语句的语法格式如下：

do {
    语句块;
}while(条件表达式);

以上语句的执行过程是，首先执行一次循环操作，然后再判断 while 后面的条件表达式是否为 true，如果循环条件满足，循环继续执行，否则退出循环。while 语句后必须以分号表示循环结束，其运行流程如图 2 所示。

例 子

编写一个程序，计算 10 的阶乘。使用 do-while 循环的实现代码如下所示。

public static void main(String[] args) {
    int number = 1,result = 1;
    do {
        result*=number;
        number++;
    }while(number <= 10);
    System.out.print("10阶乘结果是："+result);
}

while和do-while的比较

while 循环和 do-while 循环的相同处是：都是循环结构，使用 while(循环条件) 表示循环条件，使用大括号将循环操作括起来。

while 循环和 do-while 循环的不同处如下：

• 语法不同：与 while 循环相比，do-while 循环将 while 关键字和循环条件放在后面，而且前面多了 do 关键字，后面多了一个分号。
• 执行次序不同：while 循环先判断，再执行。do-while 循环先执行，再判断。
• 一开始循环条件就不满足的情况下，while 循环一次都不会执行，do-while 循环则不管什么情况下都至少执行一次。

二、for 循环

for 语句是应用最广泛、功能最强的一种循环语句。大部分情况下，for 循环可以代替 while 循环、do while 循环。

for 语句是一种在程序执行前就要先判断条件表达式是否为真的循环语句。假如条件表达式的结果为假，那么它的循环语句根本不会执行。for 语句通常使用在知道循环次数的循环中。

for 语句语法格式如下所示。

for(条件表达式1;条件表达式2;条件表达式3) {
    语句块;
}

for 循环中 3 个条件表达式的含义如表 1 所示。

for 关键字后面括号中的 3 个条件表达式必须用“;”隔开。for 循环中的这 3 部分以及大括号中使循环体必需的 4 个组成部分完美地结合在一起，简单明了。

for 循环语句执行的过程为：首先执行条件表达式 1 进行初始化，然后判断条件表达式 2 的值是否为 true，如果为 true，则执行循环体语句块；否则直接退出循环。最后执行表达式 3，改变循环变量的值，至此完成一次循环。接下来进行下一次循环，直到条件表达式 2 的值为 false，才结束循环，其运行流程如图 1 所示。

 

 值得指出的是，for 循环的循环迭代语句并没有与循环体放在一起，因此即使在执行循环体时遇到 continue 语句结束本次循环，循环迭代语句也一样会得到执行。

for 循环和 while、do while 循环不一样：由于 while、do while 循环的循环迭代语句紧跟着循环体，因此如果循环体不能完全执行，如使用 continue 语句来结束本次循环，则循环迭代语句不会被执行。但 for 循环的循环迭代语句并没有与循环体放在一起，因此不管是否使用 continue 语句来结束本次循环，循环迭代语句一样会获得执行。

与前面循环类似的是，如果循环体只有一行语句，那么循环体的大括号可以省略。

例如，同样是计算 5 的阶乘，使用 for 循环的实现代码如下：

public static void main(String[] args) {
    int result = 1;
    for (int number = 1; number <= 5; number++) {
        result *= number;
    }
    System.out.print("5 的阶乘结果是：" + result);   // 输出"5的阶乘结果是：120"
}

上述语句的含义可以理解为，将 number 变量的值从 1 开始，每次递增 1，直到大于 5 时终止循环。在循环过程中，将 number 的值与当前 result 的值进行相乘。

for 语句中初始化、循环条件以及迭代部分都可以为空语句（但分号不能省略），三者均为空的时候，相当于一个无限循环。下面对这些情况依次进行介绍。

1．条件表达式 1 为空

for 语句中条件表达式 1 的作用可以在程序的其他位置给出，所以当条件表达式 1 为空时，for 语句后面括号内其他条件表达式执行的顺序不变。

例如，使用 for 语句的这种形式计算 1~100 所有奇数的和。

public static void main(String[] args) {
    int result = 0;
    int number = 1; // 相当于for语句的第1个表达式
    for (; number < 101; number++) {
        if (number % 2 != 0) // 如果不能整除2，说明是奇数，则进行累加
            result += number;
    }
    System.out.print("100 以内所有奇数和为：" + result);
}

执行后的输出结果如下：

100 以内所有奇数和为：2500

2．条件表达式 2 为空

当 for 语句中条件表达式 2 为空时，将没有循环的终止条件。此时 for 语句会认为条件表达式 2 的值总是为真，循环无限制执行下去。因此，为了使循环达到某种条件时退出，需要在语句块中进行逻辑判断，并使用 break 语句来跳出循环，否则将产生死循环。

同样是计算 1~100 所有奇数的和，使用这种方式的代码如下。

public static void main(String[] args) {
    int result = 0;
    for (int number = 1;; number++) {
        if (number > 100)
            break; // 相当于for语句的表达式2，满足时就退出for循环
        if (number % 2 != 0) // 如果不能整除2，说明是奇数，则进行累加
            result += number;
    }
    System.out.print("100 以内所有奇数和为：" + result);
}

3．条件表达式 3 为空

当 for 语言中条件表达式 3 为空时，也就没有设置控制变量的表达式，即每次循环之后无法改变变量的值，此时也无法保证循环正常结束。

同样是计算1~100 所有奇数的和，使用这种方式的代码如下：

public static void main(String[] args) {
    int result = 0;
    for (int number = 1; number < 101;) {
        if (number % 2 != 0) // 如果不能整除2，说明是奇数，则进行累加
            result += number;
        number++; // 相当于for语句的条件表达式3，每次递增1
    }
    System.out.print("100 以内所有奇数和为：" + result);
}

如果没有循环体语句，number 变量的值为 1，永远小于 101，因此将无法结束循环，形成无限循环。在上面代码中将 number 的递增语句放在 for 循环体内，效果与完整 for 语句功能相同。

4．3 个条件表达式都为空

在 for 循环语句中，无论缺少哪部分条件表达式，都可以在程序的其他位置补充，从而保持 for 循环语句的完整性，使循环正常进行。

当 for 语句中循环体全为空时，即没有循环初值，不判断循环条件，循环变量不增值，此时无条件执行循环体，形成无限循环或者死循环。对于这种情况，读者在使用时应该尽量避免。

例如，计算 1~100 所有奇数的和，使用这种方式的代码如下： 

public static void main(String[] args) {
    int result = 0;
    int number = 1; // 相当于for语句的条件表达式1
    for (;;) {
        if (number > 100)
            break; // 相当于for语句的条件表达式2
        if (number % 2 != 0) // 如果不能整除2，说明是奇数，则进行累加
            result += number;
        number++; // 相当于for语句的条件表达式3
    }
    System.out.print("100 以内所有奇数和为： " + result);
}

for、do-while 和 while 的区别

在《Java while和do while循环》中我们学习了 do-while 和 while 循环，这一节我们又学习了 for 循环。关于 do-while 和 while 具体的相同点和不同点在刚刚提到的教程中已经介绍过了，在这里不过多讲解了。下面主要介绍它们的区别，如下表 2 所示。

for循环嵌套

和其他编程语言一样，Java 允许循环嵌套。如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环。

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

当程序遇到嵌套循环时，如果外层循环的循环条件允许，则开始执行外层循环的循环体，而内层循环将被外层循环的循环体来执行——只是内层循环需要反复执行自己的循环体而已。

当内层循环执行结束，且外层循环的循环体执行结束时，则再次计算外层循环的循环条件，决定是否再次开始执行外层循环的循环体。

根据上面分析，假设外层循环的循环次数为 n 次，内层循环的循环次数为 m 次，那么内层循环的循环体实际上需要执行 n×m 次。嵌套循环的执行流程如图 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 + "	");
        }
        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。在外层循环的当次循环里，内层循环就是一 个普通循环。

foreach语句的用法

foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。

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

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

其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。每执行一次循环语句，循环变量就读取集合中的一个元素，其执行流程如图 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 语句在遍历集合的时候要简单方便得多。

例 子

String[] urls = { "http://c.biancheng.net/java", "http://c.biancheng.net/c", "http://c.biancheng.net/golang/" };
// 使用foreach循环来遍历数组元素
// 其中book将会自动迭代每个数组元素
for (String url : urls) {
    System.out.println(url);
}

从上面程序可以看出，使用 foreach 循环遍历数组元素时无须获得数组长度，也无须根据索引来访问数组元素。

foreach 循环和普通循环不同的是，它无须循环条件，无须循环迭代语句，这些部分都由系统来完成，foreach 循环自动迭代数组的每个元素，当每个元素都被迭代一次后，foreach 循环自动结束。

当使用 foreach 循环来迭代输出数组元素或集合元素时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允许的，但没有太大的实际意义，而且极容易引起错误。例如下面程序。

String[] urls = { "http://c.biancheng.net/java", "http://c.biancheng.net/c", "http://c.biancheng.net/golang/" };
// 使用foreach循环来遍历数组元素，其中 book 将会自动迭代每个数组元素
for (String url : urls) {
    url = "https://c.biancheng.net";
    System.out.println(url);
}
System.out.println(urls[0]);

运行上边程序，将看到如下结果：

https://c.biancheng.net
https://c.biancheng.net
https://c.biancheng.net
https://c.biancheng.net/java

从上面运行结果来看，由于在 foreach 循环中对数组元素进行赋值，结果导致不能正确遍历数组元素，不能正确地取出每个数组元素的值。而且当再次访问第一个数组元素时，发现数组元素的值依然没有改变。

不难看出，当使用 foreach 来迭代访问数组元素时，foreach 中的循环变量相当于一个临时变量，系统会把数组元素依次赋给这个临时变量，而这个临时变量并不是数组元素，它只是保存了数组元素的值。因此，如果希望改变数组元素的值，则不能使用这种 foreach 循环。

使用 foreach 循环迭代数组元素时，并不能改变数组元素的值，因此不要对 foreach 的循环变量进行赋值。

例 3

在一个字符串数组中存储了几种编程语言，现在将这些编程语言遍历输出。

foreach 语句的实现代码如下：

public static void main(String[] args) {
    String[] languages={"Java","ASP.NET","Python","C#","PHP"};
    System.out.println("现在流行的编程语言有：");
    // 使用 foreach 循环语句遍历数组
    for(String lang:languages) {
        System.out.println(lang);
    }
}

在循环体执行的过程中，每循环一次，会将 languages 数组中的一个元素赋值给 lang 变量，直到遍历 languages 数组中所有元素，循环终止。

该程序运行后的结果如下所示。

现在流行的编程语言有：
Java
ASP.NET
Python
C#
PHP