第五章：循环结构-Java语言基础3-流程控制

当前位置:　首页>> 技术小册>> Java语言基础3-流程控制

5.1 概述

- 循环结构：在某些条件满足的情况下，反复执行特定代码的功能。

5.2 for 循环

- 语法：
```bash
for(初始化条件①;循环条件语句②;迭代语句④){
    循环体语句③
}
```

```bash
for(;;){
    循环体语句块；//如果循环体中没有跳出循环体的语句，那么就是死循环
}
```

注意：
for(;;){} 中的两个 ; 是不能多也不能少的。
循环条件必须是 boolean 类型。
如果循环条件语句 ② 省略的话，就默认为循环条件成立。
 执行流程： 
第一步：执行初始化语句 ① ，完成循环变量的初始化；
第二步：执行循环条件语句 ② ，看循环条件语句的值是 true ，还是 false ； 
如果是 true ，执行第三步；
如果是 false ，循环语句中止，循环不再执行。
第三步：执行循环体语句 ③ ；
第四步：执行迭代语句 ④ ，针对循环变量重新赋值；
第五步：根据循环变量的新值，重新从第二步开始再执行一遍；
 
 示例：

```bash
/**
 * 打印10次"Hello"
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class ForDemo1 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello");
        }
    }
}
```

示例：
```bash
/**
 * 从1累加到5
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class ForDemo2 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
        }
        System.out.println("sum = " + sum);
    }
}
```

示例：
```bash
/**
 * 1~100的偶数和
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class ForDemo3 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        System.out.println("sum = " + sum);
    }
}
```

示例：
```bash
/**
 * 编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class ForDemo4 {
    public static void main(String[] args) {

for (int i = 1; i <= 150; i++) {
            System.out.print(i + "\t");
            if (i % 3 == 0) {
                System.out.print("foo" + "\t");
            }
            if (i % 5 == 0) {
                System.out.print("biz" + "\t");
            }
            if (i % 7 == 0) {
                System.out.print("baz" + "\t");
            }
            System.out.println();
        }
    }
}
```

示例：
```bash
/**
 * 输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
 * <p>
 * 例如： 153 = 111 + 333 + 555
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class ForDemo5 {
    public static void main(String[] args) {
        for (int i = 100; i <= 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;

if (i == Math.pow(ge, 3) + Math.pow(shi, 3) + Math.pow(bai, 3)) {
                System.out.println("水仙花数 = " + i);
            }
        }
    }
}
```

5.3 while 循环

- 语法：
```bash
初始化语句①；
while (循环条件语句②) {
    循环体语句③；
    迭代语句④；
}
```

-  执行流程： 
  ○ 第一步：执行初始化语句 ① ，完成循环变量的初始化；
  ○ 第二步：执行循环条件语句 ② ，看循环条件语句的值是 true ，还是 false ； 
    ■ 如果是 true ，执行第三步；
    ■ 如果是 false ，循环语句中止，循环不再执行；
  ○ 第三步：执行循环体语句 ③ ；
  ○ 第四步：执行迭代语句 ④ ，针对循环变量重新赋值；
  ○ 第五步：根据循环变量的新值，重新从第二步开始再执行一遍；
 
注意：while (循环条件)中循环条件必须是 boolean 类型。

示例：
```bash
/**
 * 打印1~10
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class WhileDemo {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 10) {
            System.out.println(i);
            i++;
        }
    }
}
```

示例：
```bash
/**
 * 世界最高山峰是珠穆朗玛峰，它的高度是8845.43米，假如我有一张足够大的纸，它的厚度是0.1毫米。
 * 请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class WhileDemo2 {
    public static void main(String[] args) {
        // 统一计量单位
        double height = 88444300;
        double paper = 1.0;

// 折叠次数
        int count = 0;

// 折纸的高度，初始化时为纸张没有折叠的高度
        double paperHeight = paper;

while (paperHeight <= height) {
            // 每折叠一次，厚度翻倍
            paperHeight *= 2;
            
            // 折叠次数自增
            count++;
        }
        System.out.println("最终纸的厚度 = " + paperHeight);
        System.out.println("最终折叠的次数 = " + count);

}
}
```

示例：
```bash
import java.util.Scanner;

/**
 * 从键盘读入个数不确定的整数，并判断读入的奇数和偶数的个数，输入为0时结束程序。
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class WhileDemo3 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入整数：");
        int number = input.nextInt();

int oddCount = 0;
        int evenCount = 0;

while (number != 0) {

if (number % 2 == 0) {
                evenCount++;
            } else {
                oddCount++;
            }

System.out.print("请输入整数：");
            number = input.nextInt();
        }

System.out.println("奇数的个数 = " + oddCount);
        System.out.println("偶数的个数 = " + evenCount);
    }
}
```

5.4 do…while 循环
语法：

```bash
初始化语句①
do {
    循环体语句②；
    迭代语句③；
} while (循环条件语句④)；
```

-  执行流程： 
  ○ 第一步：执行初始化语句 ① ，完成循环变量的初始化；
  ○ 第二步：执行循环体语句 ② ；
  ○ 第三步：执行迭代语句 ③ ，针对循环变量重新赋值；
  ○ 第四步：执行循环条件语句 ④ ，看循环条件语句的值是 true ，还是 false ； 
    ■ 如果是 true ，根据循环变量的新值，重新从第二步开始再执行一遍；
    ■ 如果是 false ，循环语句中止，循环不再执行；
 
-  示例： 
```bash
/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class DoWhileTest {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        do {
            sum += i;
            i++;
        } while (i <= 100);

System.out.println("sum = " + sum);
    }
}
```

5.5 循环语句的区别

- 从循环次数角度分析： 
  ○ do...while 循环至少执行一次循环体语句。
  ○ for 和 while 循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句。
- 从循环变量的生命周期角度分析： 
  ○ for 循环的循环变量在 for() 中声明的，在循环语句结束后，不可以被访问。
  ○ while 和 do...while 循环的循环变量因为在外面声明的，所以 while 和 do...while 结束后可以被继续使用的。
- 如何选择： 
  ○ 遍历有明显的循环次数（范围）的需求，选择 for 循环。
  ○ 遍历没有明显的循环次数（范围）的需求，循环 while 循环。
  ○ 如果循环体语句块至少执行一次，可以考虑使用 do...while 循环。
  ○ 本质上：三种循环之间是可以互相转换的，都能实现循环的功能。
- 三种循环结构都具有四要素： 
  ○ ① 循环变量的初始化表达式。
  ○ ② 循环条件。
  ○ ③ 循环变量的修改的迭代表达式。
  ○ ④ 循环体语句块。
 
 
5.6 嵌套循环（多重循环）

-  将一个循环放在另一个循环体内，就形成了多重循环。其中，for 、while 、do…while 均可以作为外层循环或内层循环。 
-  实际上，嵌套循环就是将内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false ，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次循环。 
-  假设外层循环次数为 m 次，内层循环次数为 n 次，则内层循环体实际上需要执行 m*n 次。

- 示例： 
```bash
/**
 * 九九乘法表
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class ForForDemo {
    public static void main(String[] args) {
        // 外层循环控制行数
        for (int i = 1; i <= 9; i++) {
            // 内层循环控制列数
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i * j + "\t");
            }
            System.out.println();
        }
    }
}
```

5.7 控制语句

5.7.1 break

-  使用场景： 
  ○ ① 在选择结构 switch 语句中。
  ○ ② 在循环语句中。
 
-  示例： 
```bash
/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class BreakDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                // 将本层的循环结束
                break;
            }
            System.out.println(i);
        }
    }
}
```

示例：
```bash
import java.util.Scanner;

/**
 * 从键盘输入不断输入整数，输入0表示结束，统计一共有几个正数、负数。
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class BreakDemo2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

// 正数的个数
        int positive = 0;
        // 负数的个数
        int negative = 0;

while (true) {
            System.out.print("请输入数字：");
            int number = input.nextInt();

if (number > 0) {
                positive++;
            } else if (number < 0) {
                negative++;
            } else {
                break;
            }
        }

System.out.println("正数的个数 = " + positive);
        System.out.println("负数的个数 = " + negative);
    }
}
```
示例：
```bash
/**
 * 求1-100之间的质数
 * ps: 质数是指能被1和其本身整除的数
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class PrimeNumber {
    public static void main(String[] args) {

// 外层循环，列出从2~100的所有的数字
        for (int i = 2; i <= 100; i++) {
            // 标记：先设置为true，后面再使用内层循环进行排序
            boolean flag = true;
            // 内层循环：验证i变量中保存的这个数是不是质数
            // 验证方式：用i 对 从2到i/2的所有数 取模，如果发现能够整除，那么说明i不是质数
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    // 如果不是素数，就将标记改为false
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.println("i = " + i);
            }
        }

}
}
```

5.7.2 continue
-  使用场景：结束本次循环，继续下一次的循环。

- 示例：

```bash
/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class ContinueDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 3 == 0) {
                continue;
            }
            System.out.println("i = " + i);
        }
    }
}
```

示例：
```bash
/**
 * 打印1-100之间的整数，跳过7的倍数和7结尾的数
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class ContinueDemo2 {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            if (i % 7 == 0 || i % 10 == 7) {
                continue;
            }
            System.out.println("i = " + i);
        }
    }
}
```

5.7.3 return

-  reutrn ：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个 return 语句的时候，这个方法将被结束。 
-  和 break 和 continue 不同的是，return 直接结束整个方法，不管这个 return 处于多少层循环之内。

- 示例：

```bash
/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class ReturnDemo {
    public static void main(String[] args) {

for (int i = 0; i < 100; i++) {
            if (i == 7) {
                return;
            }
            System.out.println(i);
        }

}
}
```