1. 循环结构(while、do…while、for)

1.1. 什么是循环结构

在日常生活中，会有很多需要反复执行的事情，比如：每一年的4个季节，每一周的7天，每日的3餐，打印机每份文档打印50份，一圈跑道400米跑3圈，都是在反复执行的。

再看软件系统中的需求：

问题1：输出100行语句，每行语句都一样，即:

• 行动是成功的阶梯，行动越多，登得越高!
• 行动是成功的阶梯，行动越多，登得越高!
• 行动是成功的阶梯，行动越多，登得越高!

…

问题2：输出100行语句，每行语句都类似，即:

• 第1,行动是成功的阶梯，行动越多，登得越高!
• 第2,行动是成功的阶梯，行动越多，登得越高!
• 第3,行动是成功的阶梯，行动越多，登得越高!
• …
• 第100,行动是成功的阶梯，行动越多，登得越高!

问题3：计算1到50乘以8.88的结果

• 1× 8.88 ＝8.88
• 2 × 8.88 ＝17.76
• 3 × 8.88 ＝26.64
• 4 × 8.88 ＝35.52
• …
• 50 × 8.88 ＝444

诸如此类问题都是在反复执行的，在软件系统中可以通过循环这种语法结构来解决。循环是程序设计语言中反复执行某些代码的一种计算机处理过程， 是一组相同或相似语句被有规律的重复性执行。

对于循环来说，需要考虑两个要素，其一要素为循环体， 也就是被反复执行的相同或相似的语句，其二要素为循环的条件，也就是循环得以继续执行下去的条件，常常以循环次数的方式体现。

常用的循环结构有：while、do-while、for。

1.2. while语句

1.2.1. while语句的执行逻辑

while语句是循环的一种常见语法结构，语法如下：

1. while( boolean表达式 ) {         语句块；
2. }

while语句的执行过程为，首先计算boolean表达式的值，而后进行判断，若值为true则执行语句块，语句块执行完后再次判断boolean表达式的值，如果为true则继续执行语句块，如此循环往复，直到boolean表达式的值为false时退出while循环而执行while之后的语句。

1.2.2. while语句的流程图

while语句的流程图如图 - 11所示，需要注意的是，一般情况下，循环操作中会存在使得循环条件不满足的可能性，否则该循环将成为“死循环”。“死循环”意味着会一直执行循环体操作，循环后面的语句永远不会被执行，“死循环”在软件系统中是需要避免的。

1.2.3. while语句用于处理循环逻辑

while语句在实际应用中应用比较广泛，通过如下示例体会while语句的执行逻辑：

1. int age = 1;
2. while (age<=100) {
3. System.out.println(“马上有钱”);
4. age++;
5. }

上面的语句执行过程如下，首先声明整型变量age并赋初始值为1，而后判断age是否小于等于100，条件为真，输出“马上有钱”并将age的值增1变为2，再次判断条件，此时age为2，依然小于100，再一次输出“马上有钱”并将age的值再增1变为3，以此类推，直到age等于101时，判断条件为false，循环结束。

1.2.4. 使用break语句跳出循环

break用在循环体中用于退出循环结构。看如下示例代码：

1. int x = 0;
2. while ( x < 10 ) {
3.         if ( 5 == x )
4.     {
5.             break;
6.     }
7.         System.out.println(x);
8.         x + + ;
9. }

分析上面的代码得出结论，输出结果为0 1 2 3 4，因为当x等于5时执行break语句直接退出循环结构了，即if语句块后面的输出x的值以及x++不再被执行。

1.3. do-while语句

1.3.1. do-while语句的执行逻辑

do-while语句也是循环的一种常见语法结构，语法如下：

1. do {
2.         语句块
3. } while( boolean表达式 ) ;

do-while语句的执行过程为，先执行语句块，再判断boolean表达式，如果为true则再次执行语句块，如此循环往复，直到boolean表达式的值为false时止。也就是说，do-while语句，无论boolean表达式是否为true，都先执行一次语句块。

1.3.2. do-while语句的流程图

do-while语句的流程图如图 - 12所示，与while语句一样，do-while语句也要避免“死循环”的发生。

1.3.3. do-while语句用于处理循环逻辑

do-while语句在实际应用中应用比较广泛， 通过如下示例体会do-while语句的执行逻辑：

1. int pwd ;
2. do{
3.     System.out.print(“请输入密码”);
4.     pwd = scanner.nextInt();
5. } while ( 123 != pwd) ;

上面的语句执行过程如下，首先声明整型变量pwd，在do语句中提示“请输入密码”,接收用户输入的数据赋给pwd， 而后判断123是否不等于pwd，若为true则执行do语句块，以此类推，直到123等于pwd时，循环结束。

1.3.4. while和do-while语句的区别

while与do-while都是用于执行循环结构的语句，区别在于，while循环先判断再执行，而do-while循环先执行一次，再判断。那么，当初始情况不满足循环条件时，while循环就一次都不会执行，而do-while循环不管任何情况都至少会执行一次。

注意：while和do-while语句的不同仅仅体现在第一次就不满足条件的循环中；如果不是这样的情况，while与do-while可以互换。请看如下两段示例程序：

1. 示例1：while循环方式
2. int pwd = 0;
3. while ( 123 != pwd){
4.         System.out.print(“密码：”);
5.         pwd = scanner.nextInt();
6. }
7. 示例2: do-while循环方式
8. int    pwd ;
9. do{
10.         System.out.print(“密码”);
11.         pwd = scanner.nextInt();
12. } while ( 123 != pwd) ;

分析示例1与示例2得出结论，运行结果完全一样。这是因为两段代码第一次的while条件都满足，此时while与do-whlie可以互换，所以结果完全一样。

1.4. for语句

1.4.1. 考虑如下循环问题的相同之处

请考虑如下三个题目的相似之处：

1. 计算从1加到100的值；
2. 计算1+1/3+1/5+…+1/999；
3. 找出从第1号学员到第500号学员中成绩大于90的学员。

通过上面的问题可以看出，如上三个题目都是在有规律的重复执行某个操作，在程序中

考虑使用循环结构来解决。首先需要先找到前面介绍的循环变量，此循环变量在每一次的循环中有规律的发生变化，并且常常作为判断是否继续循环的条件。

首先，看第1个题目，设计循环变量i ，i的值为1,2,…,100，即：从1开始，每次增1。第二个题目，设计循环变量i , i的值为1,3,5,…,999，即：从1开始，每次增2。第三个题目，设计循环变量i , i的值为1,2,…,500，即：从1开始，每次增1。

通过上面的分析，可以看出，如上的循环都是固定次数的循环，这种情况，优先考虑使用for语句来实现。

1.4.2. for语句的执行逻辑

for语句是循环中最最常用的一种方式。for循环用于将某个语句或语句块重复执行预定次数的情形。语法如下：

1. for ( 表达式1；表达式2；表达式3 ) {
2. 语句块（循环体）
3. }

可以看出，for循环的三个表达式之间通过分号；进行分隔，其执行逻辑如下所示：

1. 计算表达式1的值，通常为循环变量赋初值；
2. 计算表达式2（表达式2为逻辑表达式）的值，即判断循环条件是否为真，若值为真则执行循环体一次(语句块)，否则跳出循环；
3. 执行循环体；
4. 计算表达式3的值，此处通常写更新循环变量的赋值表达式；
5. 计算表达式2的值，若值为true则执行循环体，否则跳出循环；
6. 如此循环往复，直到表达式2的值为false。

1.4.3. for语句的流程图

for语句流程图如图-1所示：

简单示例如下：

1. for ( int i = 1 ; i <= 10 ; i + + ) {
2.         System.out.println( i );
3. }

如上程序的输出结果为：1 2 3 4 5 6 7 8 9 10

分析如上程序的执行过程：首先，初始化i的值为1，判断i是否小于等于10，结果为true，其次，输出i的值1，然后，执行i的自增1，再判断i是否小于等于10，结果为true，执行输出i的值2，以此类推……输出i的值10后，执行i的自增1，此为i为11，判断结果为false，程序终止。

1.4.4. for语句用于实现固定次数循环

for语句常常用于解决固定次数循环的处理，比如说累加和，想求1+2+3+…+100的结果，次数固定执行100次，可以考虑使用for循环处理，参见如下代码：

1. int sum = 0 ;
2. for ( int i = 1 ; i <= 100 ; i + + ) {
3. sum += i ;
4. }
5. System.out.println(“1到100的和为：” + sum ) ;

分析上面代码的执行过程，首先，声明一个变量用于保存累加和，此变量命名为sum，赋初始值为0，而后，for循环从1开始，每次增1，执行100次，循环体中将i的值累加到sum变量中。注意：每次都是在sum的基础之上加上i，所以使用了sum += i。循环结束后，输出结果“1到100的和为：5050“。

了解了如上题目之后，问：想求10的阶乘，即1*2*3*…*10，可不可以使用for循环来解决，如果可以的话要如何解决呢？当然可以，try！！！

1.4.5. for语句三个表达式特殊用法

首先回顾for语句的语法：

1. for ( 表达式1；表达式2；表达式3 ) {
2. 语句块     }

通过上面的代码可以看出，for语句实现循环时需要3个表达式并且使用分号；分隔，

在实际使用时，for语句可以有几种特殊的使用方法：

特殊方式1：表达式1位置内容为空，看如下代码：

1. int sum = 0 ;
2. int i = 1;
3. for ( ; i <= 10 ; i + + ) {
4.         sum += i ;
5. }
6. System.out.println(“1到10的和为：” + sum ) ;

通过上面的代码可以看出，虽然省略了表达式1，但只是将它放在了for循环的外面进行声明，只是位置不同而已。在此需要注意一点，即使for语句中不写表达式1了，表达式2前面的分号；也不能省略。

特殊方式2：表达式3位置内容为空时，看如下代码：

1. int sum = 0 ;
2. for ( int i = 1 ; i <= 10 ; ) {
3. sum += i ;
4.         i + + ;
5. }
6. System.out.println(“1到10的和为：” + sum ) ;

通过上面的代码可以看出，虽然省略了表达式3，但也只是将它放在了for循环体之中，只是位置不同而已。在此需要注意一点，即使for语句中不写表达式3了，表达式2后面的分号；也不能省略。

特殊方式3：表达式1,2,3位置内容均为空时，看如下代码：

1. for ( ; ; ) {
2. System.out.println(“我要学习……”);
3. }

通过上面的代码可以看出，如上代码没有循环变量、没有条件控制，因此会造成死循环，而死循环在编写程序过程中是必须要避免的，可以在循环体中添加break跳出循环。

特殊方式4：表达式 1 和 3 位置内容的多样化

for语句中的三个表达式中表达式1和表达式3可以使用逗号表达式，逗号表达式就是通过”，”运算符隔开的多个表达式组成的表达式，从左向右进行计算。看如下示例：

1. for ( int i =1 , j = 6 ; i <= 6 ; i +=2 , j -=2 ) {
2. System.out.println(“ i , j = “ + i + “,” + j );
3. }

上面的代码的执行逻辑如下：初始设置i为1，j为6，判断i是否小于等于6，为真执行循环体，而后执行i+=2，j-=2，即：i增2，j减2。再判断i是否小于等于6，为真继续执行循环体，以此类推，直到条件为false。本程序的输出结果为：

1. i , j = 1 , 6
2. i , j = 3 , 4
3. i , j = 5 , 2 

1.4.6. 循环中使用break语句

循环中的break语句应用率很广，break可用于循环语句或switch语句中，其用于循环时，可使程序终止循环而执行循环后面的语句，常常与条件语句一起使用，看如下代码：

1. int sum = 0;
2. for(int i=1; i<=100; i++){
3. if(sum>=4000){
4. break;
5. }
6. sum += i;
7. }
8. System.out.println(sum);

上面的程序需要统计1到100的累加和，条件是当和大于等于4000时则终止计算，此案例通过在if语句中使用break实现了for语句的退出，本程序最终sum的值为：4005。

1.4.7. 循环中使用continue语句

continue语句只能用于循环中，它的作用为跳过循环体中剩余语句而执行下一次循环，看如下代码：

1. int sum = 0;
2. for(int i=1; i<=100; i++){
3. if( i % 10 == 3 ){
4. continue;
5. }
6. sum += i;
7. }
8. System.out.println(sum);

上面的程序需要统计1到100的累加和，条件是跳过所有个位为3的，此案例通过在if语句中使用continue实现了跳过for语句中剩余的循环体语句，本程序最终sum的值为： 4570。