【JavaSE】-4-循环结构

循环结构
循环结构是三大流程控制结构的最后一种，相比于顺序结构和分支结构，循环结构略复杂一些。
前面课程中已经说过，循环结构的特点是能够重复的执行某些代码。
循环结构的基本概念：
循环体：重复执行的代码称为循环体。可以是一条或者多条语句。
循环条件：循环体反复执行的判断条件。一般是关系表达式或者逻辑表达式。
循环结构的特征有2点：

1. 重复执行某些代码。----具有循环体
2. 有明确的开始和结束。----具有循环的初始状态、循环条件以及循环的控制语句
   循环的初始状态：即循环的起始状态，简单说就是循环开始的时候什么样？
   循环条件：循环体反复执行的判断条件。简单说就是判断循环是否能一直执行下去。
   循环控制语句：循环执行中每次变化的内容，简单说就是控制循环是否执行下去。
   为什么要使用循环？
3. 需求：打印10遍"Hello World"。
4. 代码：
   如果打印1000遍，打印1亿遍呢？代码怎么写？
5. 需求：计算1+2+3+4+5的和。
6. 代码：

public static void main(String[] args) {
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
}
public static void main(String[] args) {
int sum = 0;
sum = 1 + 2 + 3 + 4 + 5;
System.out.println(sum);
}

如果计算1+2+3+…+99+100的和，代码怎么写？
如果计算1+2+3+…+100000000的和，代码又该怎么写？

1. 需求：100以内的质数有几个？分别是谁？
2. 代码怎么写？
   …
   循环结构特别适合解决这种大规模计算或执行代码雷同的场景。
   Java中一共提供了3种实现循环的语法，分别是：
3. for循环
4. while循环
5. do…while循环
   for循环
   for循环是Java中最常用的循环。适用于知道循环次数的场景。
   for循环的语法格式
   for循环的执行流程
6. 首先执行表达式1，表达式1通常写循环的初始化内容，即循环的初始状态。表达式1只会执行一
   次。
7. 判断表达式2的真假。表达式2是循环的判断条件，表达式2的值为true，执行循环体，如果表达式2
   的值为false，则结束循环，执行循环之外的代码。
   for(表达式1;表达式2;表达式3){
   循环体;
   }
8. 循环体执行完毕之后，执行表达式3。表达式3是循环的控制条件，这个条件可以影响循环的次数。
9. 表达式3执行完毕之后，回到步骤2继续判断。
   表达式2的结果为false时，循环会结束。
   for循环的示例
   for循环示例1
10. 需求：通过for循环打印10遍"Hello World"
11. 代码：
    for循环的循环体一般来说比较容易理解，也比较容易找出来。在我们这个题中，循环体就是
    System.out.println(“Hello World”);
    for循环的表达式1，表达式2，表达式3是配合使用的。三者共同控制循环的执行次数。表达式1用
    于指定初始条件，表达式2是一个boolean值，用于判断循环是否继续进行，表达式3往往是循环的
    增量，用于逼近判断条件。
    一定要深入理解循环的执行流程，理解表达式1、表达式2、表达式3的关系，如何让3个表达式配
    合达到我们的目的。—打印10遍Hello World的变种写法。
    断点调试
    断点调试是开发中常用的调试技巧之一。
    所谓的断点调试，指的是在程序的某个位置打上断点，程序在运行的过程中就会停在断点处，等待我们
    进行下一步的操作。
    添加断点、移除断点
    在代码行号的左侧，双击鼠标左键，即可添加上断点；再次双击鼠标左键，即可移除断点。
    可以添加多少断点？
    理论上来讲，每一行都可以添加断点。实际上我们只在关键代码处添加断点。
    何为关键代码处？
    1.复杂业务逻辑代码的开头位置
    2.for循环的开始处
    3.容易出现错误的代码处。
    public static void main(String[] args) {
    //需求：通过for循环打印10遍"Hello World"
    //分析：
    // 1.由题意可知循环次数是10次。
    // 2.循环体是 打印 Hello World
    for(int i = 0; i < 10; i++) {
    System.out.println(“Hello World”);
    }
    }
    如何调试代码
    Step Over：执行一行代码。
    Step Into：进入代码内部（如果当前行是一个函数，会跳入到函数内部，如果只是一行普通代码，功能
    和step over一样）。
    Step Return：与Step Into配套使用，用于跳出Step Into进入的函数。
    Resume：结束当前断点，跳到下个断点位置。
    断点调试有什么用？
    断点调试就像电影的慢镜头一样，能让你看到每一步是怎么执行的。能看到每一步执行后，程序中的数
    据发生了什么样的变化。例如：变量值的更新。
    断点调试总结
    断点调试是开发项目必须具备的技能。
    一定要学会添加、删除断点，学会看断点下各个变量的变化。
    for循环示例2：
12. 需求：打印1~100之间（含1和100）所有的整数。
13. 代码：
    或者
    或者
    public static void main(String[] args) {
    //需求：打印1~100之间（含1和100）所有的整数。
    //分析：
    // 1.循环次数101次。
    // 2.循环体：打印一个整数（1~100之间）。
    for(int i = 1; i <= 100; i++) {
    System.out.println(i);
    }
    }
    public static void main(String[] args) {
    //需求：打印1~100之间（含1和100）所有的整数。
    //分析：
    // 1.循环次数101次。
    // 2.循环体：打印一个整数（1~100之间）。
    for(int i = 16; i <= 115; i++) {
    System.out.println(i-15);
    }
    }
    通过上述的案例，你会发现同样的需求，可以使用不同的方法来实现。
    在这个案例中，你要学会表达式1、表达式2、表达式3如何配合使用。—本质上是控制循环次数。
    for循环示例3：
14. 需求：打印出来100以内所有的奇数。
15. 代码：
    虽然打印的是奇数，但是循环的次数是101次。只不过对于每个数做了一次判断，是奇数才打印。
    整体的循环次数并没有减少。
    或者
    通过这个案例你会发现：表达式1，表达式2，表达式3是配合使用的，为的是控制循环次数。
    如何打印100以内所有的偶数？
    public static void main(String[] args) {
    //需求：打印1~100之间（含1和100）所有的整数。
    //分析：
    // 1.循环次数101次。
    // 2.循环体：打印一个整数（1~100之间）。
    for(int i = 100; i >= 1; i–) {
    System.out.println(101 - i);
    }
    }
    public static void main(String[] args) {
    //需求：打印出来100以内所有的奇数。
    //分析：
    // 1.循环次数101次。
    // 2.循环体：打印一个奇数。—需要判断当前数是不是奇数，是就打印，不是就不打印。
    for(int i = 0; i <= 100; i++) {
    if(i % 2 == 1) {
    System.out.println(i);
    }
    }
    }
    public static void main(String[] args) {
    //需求：打印出来100以内所有的奇数。
    //分析：
    // 1.循环次数50次。
    // 2.循环体：打印一个奇数。—起始值设置为1，增量设置为2。
    for(int i = 1; i < 100; i += 2) {
    System.out.println(i);
    }
    }
    for循环示例4：
16. 需求：求1+2+3+…+9+10的和。
17. 代码：
    打印1~100的和怎么写？
    打印1~1000000的和怎么写？
    for循环示例5：
18. 需求：求100以内所有奇数的和。
19. 代码：
    或者
    求100以内偶数的和怎么写？
    public static void main(String[] args) {
    //需求：求1+2+3+…+9+10的和。
    //分析：
    // 1.要有一个变量保存和。假定是sum
    // 2.循环次数11次。
    // 3.循环体：把数加到sum中去。
    int sum = 0;
    for(int i = 1; i <= 10; i++) {
    sum += i;
    }
    System.out.println(sum);
    }
    public static void main(String[] args) {
    //需求：求100以内所有奇数的和。
    int sum = 0;
    for(int i = 1; i < 100; i++) {
    if(i % 2 == 1) {
    sum += i;
    }
    }
    System.out.println(sum);
    }
    public static void main(String[] args) {
    //需求：求100以内所有奇数的和。
    int sum = 0;
    for(int i = 1; i < 100; i+=2) {
    sum += i;
    }
    System.out.println(sum);
    }
    for循环示例6：
20. 需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位
    数字的立方之和等于原数。
21. 代码：
    for循环示例7：
22. 需求：统计水仙花一共有多少个。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的
    立方之和等于原数。
23. 代码：
    for循环示例8：
24. 需求：数7游戏。从1到100（不含100），如果数是7的倍数或者包含7输出“过”，否则输出数字本
    身。
25. 代码：
    public static void main(String[] args) {
    //需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十
    位、百位数字的立方之和等于原数。
    //判断从 100到999哪个是水仙花数，所以循环从100到999。
    //找出数字的 个位、十位、百位分别是什么，再判断立方和是不是等于原数。
    for(int i = 100; i < 1000; i++) {
    int gw = i % 10;
    int sw = i / 10 % 10;
    int bw = i / 100;
    if(gw * gw * gw + sw * sw * sw + bw * bw * bw == i) {
    System.out.println(i);
    }
    }
    }
    public static void main(String[] args) {
    //需求：统计水仙花一共有多少个。水仙花数：是一个三位数，水仙花数的个位、十位、百位
    数字的立方之和等于原数。
    //定义一个变量count记录水仙花的个数。判断从 100到999哪个是水仙花数，所以循环从
    100到999。
    //找出数字的 个位、十位、百位分别是什么，再判断立方和是不是等于原数。
    //一旦某个数是水仙花数，就让count++.
    int count = 0;
    for(int i = 100; i < 1000; i++) {
    int gw = i % 10;
    int sw = i / 10 % 10;
    int bw = i / 100;
    if(gw * gw * gw + sw * sw * sw + bw * bw * bw == i) {
    System.out.println(i);
    count++;
    }
    }
    System.out.println(“一共有” + count + “个水仙花数。”);
    }
    随机数
    在Java中使用Random类来产生随机数。具体使用步骤如下：
26. 导包。----import java.util.Random;//快捷键：Ctrl + Shift + O
27. 创建Random对象。Random random = new Random();
28. 获取随机数。int num = random.nextInt(10);-----[0,10)
    随机数案例：
29. 需求：产生1个取值范围在[0,50)的随机数。
30. 代码：
31. 需求：产生1个取值范围在[5,18)的随机数。
32. 代码：
33. 需求：产生1个取值范围在[23,41]的随机数。
34. 代码：
    public static void main(String[] args) {
    //需求：数7游戏。从1到100（不含100），如果数是7的倍数或者包含7输出“过”，否则输
    出数字本身。
    for(int i = 1; i < 100; i++) {
    if(i % 7 == 0 || (i % 10 == 7 || i / 10 == 7)) {
    System.out.print("过 ");
    }else {
    System.out.print(i + " ");
    }
    }
    }
    public static void main(String[] args) {
    //需求：产生1个取值范围在[0,50)的随机数。
    Random random = new Random();
    int num = random.nextInt(50);
    System.out.println(num);
    }
    public static void main(String[] args) {
    //需求：产生1个取值范围在[5,18)的随机数。
    //思路：
    //1.产生一个[0,13)的随机数
    //2.在上述记过的基础上+5
    Random random = new Random();
    int num = random.nextInt(13) + 5;
    System.out.println(num);
    }
    随机数的规律：要想产生一个[min, max]之间的随机数。
    int num = random.nextInt(max - min + 1) + min;
    for循环案例9：
35. 需求：产生5个[10, 80]之间的随机数，并输出产生的数。
36. 代码：
    for循环案例10：
37. 需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。
38. 代码：
    public static void main(String[] args) {
    //需求：产生1个取值范围在[23,41]的随机数。
    //思路：
    //1.产生一个[0,19)的随机数
    //2.在上述记过的基础上+23
    Random random = new Random();
    int num = random.nextInt(19) + 23;
    System.out.println(num);
    }
    public static void main(String[] args) {
    //需求：产生5个[10, 80]之间的随机数，并输出产生的数。
    //思路：循环5次，每次产生一个随机数并打印随机数。
    //先创建Random对象
    Random random = new Random();
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(80 - 10 + 1) + 10;
    System.out.print(num + " ");
    }
    }
    public static void main(String[] args) {
    //需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。
    //思路：
    //1.定义一个变量max保存最大的数。
    //2.循环5次，每次产生一个随机数并打印随机数。
    //3.在每次循环中，判断随机产生的数和max谁大，如果随机产生的数大，把max的值更新为
    随机产生的数。
    //先创建Random对象
    Random random = new Random();
    //定义一个变量保存最大的数
    int max = 0;
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(80 - 10 + 1) + 10;
    System.out.print(num + " ");
    if(num > max) {
    max = num;
    }
    }
    System.out.println("max = " + max);
    for循环案例11：
39. 需求：随机产生5个[10, 80]之间的随机数，输出产生的数，并求出最小的数。
40. 代码：
    for循环案例12：
41. 需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数以及最大随机数的下标
    （即：第几个数最大，假定下标从0开始）。
42. 代码：
    }
    public static void main(String[] args) {
    //需求：随机产生5个[10, 80]之间的随机数，输出产生的数，并求出最小的数。
    //思路：
    //1.定义一个变量min保存最小的数。
    //2.循环5次，每次产生一个随机数并打印随机数。
    //3.在每次循环中，判断随机产生的数和min谁小，如果随机产生的数小，把min的值更新为
    随机产生的数。
    //先创建Random对象
    Random random = new Random();
    //定义一个变量保存最小的数
    int min = 80;
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(80 - 10 + 1) + 10;
    System.out.print(num + " ");
    if(num < min) {
    min = num;
    }
    }
    System.out.println("min = " + min);
    }
    public static void main(String[] args) {
    //需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数以及最大随
    机数的下标（即：第几个数最大，假定下标从0开始）。
    //思路：
    //1.定义一个变量max保存最大的数。
    //2.定义一个变量index保存最大随机数的下标。
    //3.循环5次，每次产生一个随机数并打印随机数。
    //4.在每次循环中，判断随机产生的数和max谁大，如果随机产生的数大，把max的值更新为
    随机产生的数，同时更新index的值。
    //先创建Random对象
    Random random = new Random();
    //定义一个变量保存最大的数
    int max = 0;
    //定义一个变量保存最大数的下标
    int index = 0;
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(80 - 10 + 1) + 10;
    System.out.print(num + " ");
    if(num > max) {
    for循环案例13：
43. 需求：产生5个[10,20]之间的随机数，输出产生的数，并计算随机数的和以及平均值。
44. 代码：
    for循环总结
    for循环是最常用的循环，开发中几乎90%左右的循环都是for循环，for使用场景是明确知道循环次数的
    情形。
    while循环
    while是Java中第二常用的循环。while循环能实现for循环全部的功能，即：while循环可以替代for循
    环。除此以外，while循环还适用于不知道具体循环次数的循环（只知道循环结束条件，但不清楚循环
    多少次结束。）。
    while循环最大的特点：适用于不知道循环次数的循环。
    在开发中，如果知道循环次数，往往使用for循环（因为for循环的格式比较简洁，书写比较方
    便），只有不知道循环次数的时候，才使用while循环。
    max = num;
    index = i;
    }
    }
    System.out.println("max = " + max + ", index = " + index);
    }
    public static void main(String[] args) {
    //需求：产生5个[10, 20]之间的随机数，输出产生的数，并计算随机数的和以及平均值。
    //思路：
    //1.定义一个变量sum保存随机数的和。
    //2.定义一个变量avg保存随机数的平均数。
    //3.循环5次，每次产生一个随机数并打印随机数，将随机数的值加到sum中。
    //4.通过sum求avg
    //先创建Random对象
    Random random = new Random();
    //定义一个变量保存随机数的和。
    int sum = 0;
    //定义一个变量保存随机数的平均值。
    double avg = 0;
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(20 - 10 + 1) + 10;
    System.out.print(num + " ");
    sum += num;
    }
    avg = 1.0 * sum / 5;
    System.out.println("sum = " + sum + ", avg = " + avg);
    }
    while循环的语法格式
    while循环的执行流程
45. 计算条件表达式的值。
46. 如果条件表达式的值为true，执行循环体。
47. 执行完循环体以后，回到步骤1。
48. 如果条件表达式的值为false，结束循环的执行。
    while循环的示例
    while循环替代for循环
    while循环示例1：
49. 需求：通过while循环打印10遍"Hello World"
50. 代码：
    while(条件表达式){
    循环体;
    }
    public static void main(String[] args) {
    //需求：通过while循环打印10遍"Hello World"
    //分析：
    //1.循环体是 打印"Hello World"
    //2.循环结束的条件是打印10遍"Hello World"
    //—因此需要有一个计数器(变量)，帮我们记录打印了几次（每打印一次，count就自增
    1）
    //—循环执行的条件：计数器不够十次。
    int count = 0;
    while(count < 10) {
    System.out.println(“Hello World”);
    count++;//每打印一次，count就自增1
    }
    }
    while循环示例2：
51. 需求：打印1~100之间（含1和100）所有的整数。
52. 代码：
    while循环示例3：
53. 需求：打印出来100以内所有的偶数。
54. 代码：
    while循环示例4：
55. 需求：求100以内所有奇数的和。
56. 代码：
    public static void main(String[] args) {
    //需求：打印1~100之间（含1和100）所有的整数。
    //分析：
    //1.循环体是打印整数
    //2.循环结束的条件是打印完1~100之间所有的整数。
    //—因此，需要有一个变量来表示当前正在打印的整数，当前数打印完之后要换下一个数。
    //—循环条件：当前打印的整数没有超出[1, 100]范围
    int num = 1;
    while(num <= 100) {
    System.out.println(num);//打印当前的数
    num++;//换下一个数
    }
    }
    public static void main(String[] args) {
    //需求：打印出来100以内所有的偶数。
    //分析：
    //1.循环体：打印偶数
    //2.循环结束条件是打印完100以内所有的偶数。
    //—因此，需要有一个数表示当前数字（可能是偶数，可能是奇数）。判断数字的奇偶，如
    果是偶数就打印，如果是奇数不做任何处理。无论这个数字是否是偶数，判断完之后要换下一个数字。
    //—循环执行条件：尚未检查完100以内所有的数字
    int num = 0;
    while(num <= 100) {
    if(num % 2 == 0) {
    System.out.println(num + " ");
    }
    num++;
    }
    }
    public static void main(String[] args) {
    //需求：求100以内所有奇数的和。
    //分析：
    //1.循环体：把奇数加到sum中去。—定义一个表示和的变量sum，在循环体中把奇数加到
    sum中去
    //2.循环结束的条件：100以内的数字全判断完毕。
    while循环示例5：
57. 需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位
    数字的立方之和等于原数。
58. 代码：
    while循环示例6：
59. 需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。
60. 代码：
    //—因此，需要有一个数表示当前数字。对这个数字判断奇偶，如果是奇数，加到sum中
    去，如果是偶数，不做处理。判断完毕之后，无论奇偶都要换下一个数字。
    //—循环执行的条件，100以内的数据尚未检查完毕。
    int sum = 0;
    int num = 0;
    while(num < 100) {
    if(num % 2 == 1) {
    sum += num;
    }
    num++;
    }
    System.out.println(sum);
    }
    public static void main(String[] args) {
    //需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十
    位、百位数字的立方之和等于原数。
    //分析：
    //1.循环体：判断数字是不是数显花数
    //2.循环结束条件：100~1000（不含1000）之间，所有的数都判断了一遍。
    //—因此，需要定义一个变量表示当前数字。判断这个数字是不是水仙花数，是的话打印这
    个数。判断完后，无论是否是水仙花数，都要换下一个数。
    //—循环执行的条件，100~1000之间的数尚未判断完毕。
    int num = 100;
    while(num < 1000) {
    int gw = num % 10;
    int sw = num / 10 % 10;
    int bw = num / 100;
    if(gw * gw * gw + sw * sw * sw + bw * bw * bw == num) {
    System.out.print(num + " ");
    }
    num++;
    }
    }
    public static void main(String[] args) {
    //需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。
    //分析：
    //1.定义一个变量max保存最大的随机数。
    //2.定义一个变量count记录随机数的个数。
    //3.循环体：产生随机数，输出随机数，判断随机数和max的大小，如果随机数大，把max更
    新为随机数的值，coun自增1
    while循环替代for循环总结
    通过上述种种示例，不难发现while确实可以替代for循环。而且可以发现for循环中的表达式1，表达式
    2，表达式3以及循环体，在while循环中都有出现。
    for循环的表达式1对应的是while循环之前的循环初始条件。
    for循环的表达式2对应的是while循环的条件表达式。
    for循环的表达式3对应的是while循环中的 变量自增。
    for循环的循环体对应的是while循环中除了变量自增之外的全部内容。
    while循环的完整语法格式是：
    开发中，如果知道循环次数，一般使用for循环，不使用while循环。–因为for简单。
    while循环自身特长：不知道循环次数
    while循环示例1：
61. 需求：限定用户输入内容。提示用户输入1~7（含1和7）之间的数字。如果用户输入的数字范围不
    在1~7之内，让用户重新输入，直到用户输入的数字符合要求。
62. 代码：

//4.循环执行的条件：尚未产生5个随机数
int count = 0;
int max = 0;
Random random = new Random();
while(count < 5) {
int num = random.nextInt(80 - 10 + 1) + 10;
System.out.print(num + " ");
if(num > max) {
max = num;
}
count++;
}
System.out.println("max = " + max);
}
循环的初始条件;//对应for循环的 表达式1
while(条件表达式){//对应for循环的 表达式2
循环体;//对应for循环的 循环体
循环增量;//对应for循环的表达式3
}
while循环示例2：
1. 需求：输入一个整数，判断是几位数。
2. 代码：
while循环示例3：
1. 需求：世界上最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如有一张足够大的纸，它的
厚度是0.1毫米。请问折叠多少次，可以折成珠穆朗玛峰的高度？
2. 代码：
public static void main(String[] args) {
//需求：限定用户输入内容。提示用户输入1~7（含1和7）之间的数字。
//如果用户输入的数字范围不在1~7之内，让用户重新输入，直到用户输入的数字符合要求。
int num = 0;
Scanner scanner = new Scanner(System.in);
while(num > 7 || num < 1) {
System.out.print("请输入1~7(含1和7)之间的数字:");
num = scanner.nextInt();
}
System.out.println("您输入的数字是：" + num);
}
public static void main(String[] args) {
//需求：输入一个整数，判断是几位数。
//分析：
//1.对于一个数而言，除以10，相当于抹掉了1位（个位）。再除以10，相当于又抹掉了一
位。也就是说判断一个数是几位数，就看能除以10几次（除后商不为0）
//2.循环体：将整数更新为除以10以后的数。计数器自增1.
//3.循环执行的条件：整数不为0。

int count = 0;
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int num = scanner.nextInt();
while(num != 0) {
num = num / 10;
count++;
}
System.out.println("你输入的是一个" + count + "位数！");
}
public static void main(String[] args) {
//需求：世界上最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如有一张足够大的
纸，它的厚度是0.1毫米。
//请问折叠多少次，可以折成珠穆朗玛峰的高度？
//分析：
//1.纸每折叠一次，都是上一次厚度的2倍。
//2.循环体：更新当前厚度，更新折叠次数。
//3.循环执行条件：厚度小于珠穆朗玛峰的高度。
double thickness = 0.1;
int count = 0;
while(thickness <= 8844430) {
thickness *= 2;
while循环示例4：
1. 需求：生成2个[10, 20]之间的随机数，如果生成的2个数不相等，再重新生成，直到2个数相等。
2. 代码：
while循环示例5：
1. 需求：如果你是一个富二代，你有10亿元（1000000000），每天花一半，多天可以花完。
2. 代码：
while循环总结---不知道循环次数
while循环最大的用途就是处理不知道循环次数的循环，这一点是for无法做到的。在开发中，凡是用到
while的地方，都是因为需要循环，但不知道具体要循环几次。
while总结
1. while可以实现for循环的全部功能
2. while循环善于处理不知道循环次数的循环。
3. 开发中使用的是while的第二种功能。
count++;
}
System.out.println("达到珠穆朗玛峰的高度，需要折叠" + count + "次，此时纸的
厚度是" + thickness + "毫米");
}
public static void main(String[] args) {
//需求：生成2个[10, 20]之间的随机数，如果生成的2个数不相等，再重新生成，直到2个
数相等。
Random random = new Random();
int num1 = random.nextInt(20 - 10 + 1) + 10;
int num2 = random.nextInt(20 - 10 + 1) + 10;
System.out.println("num1 = " + num1 + ", num2 = " + num2);
while(num1 != num2) {
num1 = random.nextInt(20 - 10 + 1) + 10;
num2 = random.nextInt(20 - 10 + 1) + 10;
System.out.println("num1 = " + num1 + ", num2 = " + num2);
}
}
public static void main(String[] args) {
// 需求：如果你是一个富二代，你有10亿元（1000000000），每天花一半，多天可以花
完。
int money = 1000000000;
int day = 0;
while (money != 0) {
money /= 2;
day++;
}
System.out.println("10亿元可以花" + day + "天！");
}

do…while循环
do…while是Java中第三种循环结构，是使用频率最低的循环结构。do…while循环能实现while循环全部
的功能，do…while循环和while循环的唯一区别是，do…while循环会至少执行一次循环。
do…while循环的语法格式
注意：上述格式中，while(表达式)后面有一个分号。
do…while循环的执行流程

1. 执行循环体语句。
2. 判断表达式的值是否为true。如果为true，执行步骤1。
3. 如果表达式的值为false，结束循环。
   while循环是先判断条件在决定是否执行循环体
   do…while是先执行循环体再判断条件。即：至少执行一次循环体。
   do…while循环的示例
   do…while循环示例1：
4. 需求：打印1~100之间（含1和100）所有的整数。
5. 代码：

do{
循环体;
}while(表达式);
public static void main(String[] args) {
//需求：打印1~100之间（含1和100）所有的整数。
//分析：
//1.循环体：打印一个整数。
//2.循环次数：100次。
//3.起始条件：从数字1开始
//4.循环控制：数字增1
//4.循环条件：数字小于等于100

do…while循环示例2：

1. 需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位
   数字的立方之和等于原数。
2. 代码：
   do…while循环示例3：
3. 需求：输入一个整数，判断是几位数。
4. 代码：

int i = 1;
do {
System.out.println(i);
i++;
}while(i <= 100);
}
public static void main(String[] args) {
//需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十
位、百位数字的立方之和等于原数。
//分析：
//1.循环的起始状态：从数字100开始
//2.循环控制：数字每次加1
//3.循环执行条件：数字小于1000
//4.循环体：判断数字是不是水仙花数。
int num = 100;
do {
int gw = num % 10;
int sw = num / 10 % 10;
int bw = num / 100;
if(gw * gw * gw + sw * sw * sw + bw * bw * bw == num) {
System.out.println(num);
}
num++;
}while(num < 1000);
}
public static void main(String[] args) {
//需求：输入一个整数，判断是几位数。
//分析：
//1.定义变量接收输入的整数
//2.创建Scanner对象
//3.提示用户输入
//4.接收用户输入的数据
//5.定义一个计数器，记录位数
//5.判断数字的位数
// 循环体：1.让数字位数减少1位，（数字 /= 10） 2.计数器加1
// 循环执行条件：数字不等于0
int num = 0;
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
num = scanner.nextInt();

do…while示例4：

1. 需求：生成2个[10, 20]之间的随机数，如果生成的2个数不相等，再重新生成，直到2个数相等。
2. 代码：
   do…while总结
   do…while本质上和while差不多，既能胜任知道循环次数的情形，也能胜任不知道循环次数的情形。与
   while的不同点是先执行循环体，再判断条件是否成立。
   开发中do…while的使用频率比较低。因为while循环可以替代do…while，只需要在while循环之前，先把
   循环体的代码写一遍即可。
   for、while、do…while区别
   上述代码执行完毕后，会打印什么结果？

int count = 0;
do {
num /= 10;
count++;
}while(num != 0);
System.out.println("您输入了一个" + count + "位数。");
}
//需求：生成2个[10, 20]之间的随机数，如果生成的2个数不相等，再重新生成，直到2个数相等。
Random random = new Random();
int num1 = 0;
int num2 = 0;
do {
num1 = random.nextInt(20 - 10 + 1) + 10;
num2 = random.nextInt(20 - 10 + 1) + 10;
System.out.println(num1 + " " + num2);
}while(num1 != num2);
System.out.println("两个数相等了。这两个数是：" + num1 + " " + num2);
public static void main(String[] args) {
for(int i = 5; i < 5; i++) {
System.out.println("for循环");
}
int j = 5;
while(j < 5) {
System.out.println("while循环");
j++;
}
int k = 5;
do {
System.out.println("do..while循环");
k++;
}while(k < 5);
}

do…while至少执行一次循环体。
for循环中定义的变量i，只能在for循环里用，出了for循环就不能使用了。
对于while循环的 j 以及do…while循环的k来说，他们定义在了循环的外面，因此可以在循环结束后
使用。
死循环
死循环，即无限循环。循环一旦开始就永远不会停止。在开发过程中，应当避免死循环。
死循环示例：
死循环示例-for循环
代码：
上面的示例，没有任何语句控制循环的结束。所以会无限打印hello world，导致循环后面的代码
永远执行不到。
注意：如果程序中出现死循环，Eclipse会报错，不允许你执行。
代码：

public static void main(String[] args) {
for(int i = 1; i < 3; i++) {
System.out.println(i);
}
//System.out.println(i);
System.out.println("---华丽的分割线---");
int j = 1;
while(j < 3) {
System.out.println(j);
j++;
}
System.out.println(j);
System.out.println("---华丽的分割线---");
int k = 1;
do {
System.out.println(k);
k++;
}while(k < 3);
System.out.println(k);
}
public static void main(String[] args) {
for( ; ; ) {
System.out.println("hello world");
}
System.out.println("end");//这行代码永远执行不到
}
上面的示例，虽然表达式完整，但是 i != 10会永远为真，因此也是一个死循环。导致for循环后面
的代码无法执行
死循环示例-while
代码：
上面的示例，也是一个死循环，i 初始值是0，在循环体里没有任何操作去改变 i 的值，因此 i <
100永远为真，循环会无限执行，while循环后面的代码永远不会被执行到。很多新手，在写while
循环的时候容易漏写i++。
正数因为这个原因，通常使用for循环不使用while循环。
代码：
这也是一个死循环。循环条件永远是true。
死循环示例-do..while
代码：
上面的示例，和while死循环的案例一样，也是因为 缺少 i++。
public static void main(String[] args) {
for(int i = 0 ; i != 10 ; i += 3 ) {
System.out.println("hello world");
}
System.out.println("end");//这行代码永远执行不到
}
public static void main(String[] args) {
int i = 0;
while(i < 100) {
System.out.println(i);
}
System.out.println("end");
}
public static void main(String[] args) {
while(true) {
System.out.println("hello world");
}
}
public static void main(String[] args) {
int i = 0;
do {
System.out.println(i);
}while(i < 100);
System.out.println("end");
}

这也是一个死循环。循环条件永远是true。
如何避免死循环

1. 对于知道循环次数的情形，使用for循环。----for循环的语法格式，表达式3处写循环控制语句，不
   容易忘记。while和do…while容易忘记。
2. 写完代码以后，找临界值试试验证代码的正确性。
3. 借助break结束循环。
   break、continue关键字
   结束循环
   结束循环的方式一共有2种：
4. 循环正常结束，即循环条件不再满足时，循环正常结束。
5. 强行结束循环，即break关键字。
   在开发中无论是循环的正常结束还是通过break让循环结束，都是非常非常常见的。
   break关键字
   break关键字一共2个用途：
6. 用在switch…case语句中的每个case里，用于结束switch语句。
7. 用在循环结构的循环体中，用于结束当前循环的执行。—即：break写在哪个循环里，就结束哪个
   循环。
   如果break出现在循环体里，break用于结束当前循环。
   如果循环体内，break后面还有别的代码，break后面的代码不会执行。----仅限循环体内的代码。
   循环体外的代码可以正常执行。
   如果循环次数尚未用完，执行到了循环体中的break语句，也是直接结束循环，未执行的循环次数
   不再执行。
   break可以出现在for循环里，可以出现在while循环里，也可以出现在do…while循环里。
   break示例1：
8. 需求：产生10个[10, 20]之间的随机数，产生随机数的过程中，如果某个随机数的值是16，结束循
   环。
9. 代码：

public static void main(String[] args) {
do {
System.out.println("hello world");
}while(true);
}

break示例2：

1. 需求：用户可以在控制台输入任意字符串，当用户输出字符串是"exit"的时候，认为是结束输出，
   用户将不能再输入任何内容。
2. 代码：
   break示例3：
3. 需求：猜数字。产生1个[10, 30]的随机数，从键盘上输入你的猜测结果，如果猜测的数比随机数
   大，提示"你猜的数据大了"，如果猜测的数比随机数小，提示"你猜测的数据小了"，如果猜测的数
   和随机数一样大，提示"恭喜你猜对了"，计算出猜了几次才猜对。
4. 代码：
   public static void main(String[] args) {
   //需求：产生10个[10, 20]之间的随机数，产生随机数的过程中，如果某个随机数的值是
   16，结束循环。

Random random = new Random();
for(int i = 0; i < 10; i++) {
int num = random.nextInt(20 - 10 + 1) + 10;
System.out.print(num + " ");
if(num == 16) {
break;
}
}
}
public static void main(String[] args) {
//需求：用户可以在控制台输入任意字符串，当用户输出字符串是"exit"的时候，认为是结
束输出，用户将不能再输入任何内容。
System.out.println("请随意输入内容，想结束的时候输出exit并按回车。");
Scanner scanner = new Scanner(System.in);
while(true) {
//获取用户输入的内容
String str = scanner.nextLine();
if(str.equals("exit")) {
break;
}
}
}

public static void main(String[] args) {
//需求：猜数字。产生1个[10, 30]的随机数，从键盘上输入你的猜测结果，
//如果猜测的数比随机数大，提示"你猜的数据大了"，如果猜测的数比随机数小，提示"你猜
测的数据小了"，
//如果猜测的数和随机数一样大，提示"恭喜你猜对了"，并计算出猜了几次才猜对。
//生成一个[10, 30]的随机数。
Random random = new Random();
int num = random.nextInt(30 - 10 + 1) + 10;
//定义变量，记录猜测的次数。
int count = 0;
//创建Scanner对象
Scanner scanner = new Scanner(System.in);
break示例4：

1. 需求：限定用户输入内容。提示用户输入1_{7之间（含1和7）的数字。如果用户输入的不是1}7之
   间的数字，让用户继续输入，如果输入是1~7之间的数，则结束循环。
2. 代码：
   break的使用场景举例：
3. 从数组中查找某个数据，一旦找到，就结束循环。—数组是后面要学习的内容。
4. 用在死循环里，用于结束死循环（通常是达到了某个条件）。
5. 游戏里，将游戏中的怪物随机刷新在游戏地图里，如果怪物被刷新到了障碍物里（例如：
   河、山、树等），重新随机怪物的位置。
   break关键字通常情况下和if语句搭配使用。
   continue关键字
   continue关键字的作用是用于结束本次循环。例如：循环体里一共有10行代码，第5行出现了
   continue，当执行完continue以后，本次循环中第6行到第10行代码将不再执行。
   continue只是结束本次循环，而不是结束整个循环。continue通常情况下也是与if语句搭配使用。

//开始猜测
while(true) {
System.out.print("请输入猜测的数字：");
int yourAnswer = scanner.nextInt();
count++;//每次1次，计数器加1。
if(yourAnswer > num) {
System.out.println("你猜测的数据大了。");
}else if(yourAnswer < num) {
System.out.println("你猜测的数据小了。");
}else {
System.out.println("恭喜你猜对了。" + "随机产生的数是：" + num +
", 你猜了" + count + "次猜对了！");
break;
}
}
}
public static void main(String[] args) {
//需求：限定用户输入内容。提示用户输入1~7之间（含1和7）的数字。
//如果用户输入的不是1~7之间的数字，让用户继续输入，如果输入是1~7之间的数，则结束
循环。
Scanner scanner = new Scanner(System.in);
while(true) {
System.out.print("请输入1~7之间的数字：");
int num = scanner.nextInt();
if(num >= 1 && num <= 7) {
break;
}else {
System.out.println("输入的数据有误！");
}
}
}

continue示例1：

1. 需求：打印100以内所有的奇数。
2. 代码：
   continue示例2：
3. 需求：打印100以内的整数，遇到7的倍数或者含7的数字跳过。
4. 代码：
   break、continue总结
5. break用于结束当前循环。
6. continue用于结束本次循环。
7. break、contine通常是与if语句连用。即某种条件满足时才break或continue。
8. break使用比较频繁，经常用在死循环里结束循环。或者用在for循环里提前结束循环。
9. continue很少使用。

public static void main(String[] args) {
//需求：打印100以内所有的奇数。
for(int i = 1; i < 100; i++) {
if(i % 2 == 0) {
continue;
}
System.out.println(i);
}
}
public static void main(String[] args) {
//需求：打印100以内的整数，遇到7的倍数或者含7的数字跳过。
for(int i = 1; i < 100; i++) {
if(i % 7 == 0 || (i % 10 == 7 || i / 10 == 7)) {
continue;
}
System.out.print(i + " ");
}
}