4、循环结构-for-while-do..while

1、循环结构_循环概述与基本组成部分

循环结构的基本组成部分，一般可以分成四部分：
1.初始化语句：在循环开始最初执行，而且只做唯一一次。
2.条件判断：如果成立，则循环继续；如果不成立，则循环退出。
3.循环体：重复要做的事情内容，若干行语句。
4.步进语句：每次循环之后都要进行的扫尾工作。

2、循环结构_for循环

public class Demo1For {
/*
格式：
for（初始化语句；条件判断语句；条件控制语句）{
循环体语句；
}

执行流程：
执行初始化语句
执行条件判断语句，看其结果是true还是false
        如果是false，循环结束
        如果是true，继续执行
执行循环体语句
执行条件控制语句
回到1继续

需求：程序模拟折返跑3次的过程
*/

    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            System.out.println("折返跑");
        }
    }
}

public class Demo09For {
    public static void main(String[] args) {
      /*for（初始化语句;条件判断;步进语句）{
       循环体
       }*/

        for (int i = 1; i <= 100; i++) {
            System.out.println("我错啦！原谅我吧！" + i);
        }
        System.out.println("程序停止");
    }
}

public class Demo2For {
/*
需求：在控制台输出1-5和5-1的数据

分析：
1.从1开始到5结束，设置初始化从1开始
2.设置判断条件为没有到5的时候继续执行，执行到超过5程序结束
3.从1到5，每次增加1，设置条件控制每次+1
4.将反复进行的事情写入循环结构内部，打印对应数据

注意：
1.循环中，控制循环的变量，可以作为逻辑组织到循环体中进行使用的.
2.循环的条件控制语句，不要局限的认为只能是++
*/

    public static void main(String[] args) {
        //1.从1开始到5结束，设置初始化从1开始
        //2.设置判断条件为没有到5的时候继续执行，执行到超过5程序结束
        //3.从1到5，每次增加1，设置条件控制每次+1
        for (int i = 1; i <= 5; i++) {
            //4.将反复进行的事情写入循环结构内部，打印对应数据
            System.out.println(i);

            System.out.println("---------------");
            for (int i = 5; i >= 1; i--) {
                System.out.println(i);
            }
        }
    }
}

public class Demo3For {
/*
需求：求1-5之间的数据和，并把求和结果在控制台输出

分析：
1.求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
2.在循环中初始化一个变量从1开始，不断++，增长到5
3.循环的过程中，将能够代表（1-5）的i变量和sum进行累加
4.当循环执行完毕时，将最终数据打印出来

注意：
如果在今后的需求中，看到了xxxx求和的字样，就要定义一个求和变量
int sum=0；
*/

    public static void main(String[] args) {
        //1.求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
        int sum = 0;
        //2.在循环中初始化一个变量从1开始，不断++，增长到5
        for (int i = 1; i <= 5; i++) {
            //3.循环的过程中，将能够代表（1-5）的i变量和sum进行累加
            //sum=sum +i；
            sum += i;
        }
        //4.当循环执行完毕时，将最终数据打印出来
        System.out.println("数据1-5的和为：" + sum);
    }
}

public class Demo4For {
/*
需求：求1-100之间的偶数和，并把求和结果在控制台输出

分析：
1.需求是要求和，定义求和变量。
2.循环中获取1-100之间的每一个数值
3.循环的过程中，对每一个数值进行if判断，判断是否是偶数
4.是偶数的话，跟求和变量累加
5.循环结束后，打印最终结果
*/

    public static void main(String[] args) {
        //1.需求是要求和，定义求和变量
        int sum = 0;
        //2.循环中获取1-100之间的每一个数值
        for (int i = 1; i <= 100; i++) {
            //3.循环的过程中，对每一个数值进行if判断，判断是否是偶数
            if (i % 2 == 0) {
                //4.是偶数的话，跟求和变量累加
                sum += i;
            }
            //5.循环绪束后，打印最终结果
            System.out.println("1-100之间的偶数和为：" + sum);
        }
    }
}

public class Demo5For {
/*
需求：在控制台输出所有的“水仙花数"
      水仙花数是一个三位数
      水仙花数的个位、十位、百位的数字立方和等于原数

分析：
1.通过循环获取所有的三位数100-999
2.将每一个三位数拆分为个位，十位，百位
3.加入if判断条件，计算是否是水仙花数，是的话输出打印.
*/

    public static void main(String[] args) {
        //1.通过循环获取所有的三位数100-999
        for (int i = 100; i <= 999; i++) {
            //2.将每一个三位数拆分为个位，十位，百位
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;
            //int bai=i/100；
            //3.加入if判断条件，计算是否是水仙花数，是的话输出打印。
            if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == i) {
                System.out.println(i);
            }
        }
    }
}

public class Demo6For {
    public static void main(String[] args) {
        System.out.println("传智播客");
        System.out.println("黑马程序员");
        System.out.print("传智专修学院");
        System.out.println();//括号里什么都不输入代表直接换行
        System.out.print("博学谷");
    }
}

public class Demo5For {
    /*
    需求：在控制台输出所有的“水仙花数”，要求每行打印2个
    System.out.print（打印内容）；打印后不换行
    System.out.println（打印内容）；打印后换行
    
    分析：
    1.定义变量count，用于保存打印过”的数量，初始值为0
    2.在判定和打印水仙花数的过程中，拼接空格，但不换行，并在打印后让count变量+1，记录打印过的数量
    3.在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行。
    */
    public static void main(String[] args) {
        //1.定义变量count，用于保存"打印过"的数量，初始值为0
        int count = 0;
        for (int i = 100; i <= 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;

            if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == i) {
                //2.在判定和打印水仙花数的过程中，拼接空格，但不换行，并在打印后让count变量+1，记录打印过的数量
                System.out.print(i + " ");//链接空格
                count++;
                //3.在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行
                if (count % 2 == 0) {
                    System.out.println();
                }
            }
        }
    }
}

3、循环结构_while循环

1、while和for两种循环使用上其实是一样的。只是执行语句摆放位置不同而已。
2、明确循环次数使用for循环，不明确循环次数，建议使用while循环

public class WhileDemo {
/*
完整格式：
初始化语句；
while（条件判断语句）{
循环体语句；条件控制语句；
}

执行流程：
1.执行初始化语句
2.执行条件判断语句，看其结果是true还是false如果是false，循环结束
如果是true，继续执行
3.执行循环体语句
4.执行条件控制语句
5.回到o继续
需求：在控制台打印1-100之间所有的数
*/

    public static void main(String[] args) {
        //需求：在控制台输出1-100之间所有的数
        //for循环实现
        for (int i = 1; i <= 100; i++) {
            System.out.println("i");
        }
        System.out.println("--------");

        //while循环实现
        int i = 1;
        //while(i<=100);
        //千万不要在while后面添加分号，因为会一直判断小于1无限循环下去的
        while (i <= 100) {
            System.out.println("i");
            i++;
        }
    }
}

//while和for两种循环使用上其实是一样的。
public class Demo10while {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println("我错啦！" + i);
        }
        System.out.println("==============");

        int i = 1;   //1.初始化语句
        while (i <= 10) {  //2.条件判断
            System.out.println("我错啦！" + i);  //3.循环体
            i++;  //4.步进语句
        }
    }
}

while循环案例-珠穆朗玛峰

public class WhileTest {
/*
需求：世界最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度？

步骤：
1.定义计数器变量，准备用于统计折叠的次数
2.准备纸张厚度变量，珠峰高度变量
3.折叠的过程是多次，所以使用循环，不确定循环次数，使用while循环
进入循环的条件为（厚度没有超过珠峰的高度就折叠）
4.每折叠一次，计数器就要自增（查数）
5.循环结束后，打印计数器变量即可。
*/

    public static void main(String[] args) {
        //定义一个计数器，初始值为0
        int count = 0;
        //定义纸张厚度
        double paper = 0.1;
        //定义珠穆朗玛峰的高度
        int zf = 8844430;
        //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
        //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
        while (paper <= zf) {
            //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
            paper *= 2;
            //每执行完一次，我都要看一下那厚度有多少
            System.out.println(paper);
            //在循环中执行累加，对应折叠了多少次
            count++;
        }
        //打印计数器的值
        System.out.println("需要折叠：" + count + "次");
    }
}

4、循环结构_do-while循环

和for、while循环区别是，执行第一次的时候是直接134内容没有进行条件判断，第二次执行才进行条件判断。

public class DoWhileDemo {
/*
完整格式：
初始化语句；
do{
循环体语句；
条件控制语句；
}while（条件判断语句）；

执行流程：
1.执行初始化语句2.执行循环体语句
3.执行条件控制语句
4.执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
5.回到1继续

特点：
do..while循环，无论循环条件是否满足，都至少会执行一次循环体。
原因：do..while循环是从上到下依次执行。
*/

    public static void main(String[] args) {
        //需求：在控制台打印10次黑马程序员
        //do...while循环实现
        //int i = 11;
        //无论循环条件是否满足，都至少会执行一次循环体。
        int i = 1;
        do {
            System.out.println("黑马程序员");
            i++;
        } while (i <= 10);
        //System.out.println("i");//输出为12，因为至少都会执行一次循环体
    }
}

public class Demo11Dowhile {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println("原谅你啦！起来吧！地上怪凉！" + i);
        }
        System.out.println("===============");

        int i = 1; //1.初始化语句
        do {
            System.out.println("原谅你啦！起来吧！地上怪凉！" + i);//3.循环体
            i++;  //4.步进语句
        } while (i <= 10); //2.条件判断
    }
}

5、三种循环的区别

public class Loop {
/*
for和while的区别：

条件控制语句所控制的自增变量
因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了

条件控制语句所控制的自增变量
对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
*/

    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            //for循环内部[定义]的变量，在循环结束后，就会从内存中消失
            System.out.println("i");
        }
        //System.out.println("i");
        //错误：找不到符号。在for循环结束后，i从内存中消失了。不能再次被访问了
        System.out.println("--------");

        for (int i = 1; i <= 10; i++) {
            //上面定义的i已经循环完成从内存中消失了，在大括号外再定义i不会有影响
            System.out.println("i");
        }
        System.out.println("--------");

        //while循环
        int a = 1;
        while (a <= 5) {
            System.out.println("a");
            a++;
        }
        System.out.println("a" + "...");
    }
}

public class Demo13LoopDifference {
    public static void main(String[] args) {


        for (int i = 1; i < 0; i++) {
            System.out.println("Hello");
            //system.out.println(i);//这一行是错误写法！因为变量i定义在for循环小括号内，只有for循环自己才能用。
            System.out.println("================");
        }


        int i = 1;
        do {
            System.out.println("World");
        } while (i < 0);
        //现在已经超出了do-while循环的范围，我们仍然可以使用变量i
        System.out.println("i");//因为do-while至少运行了1次，所以输出结果为2
    }
}

6、循环控制_break语句（跳转控制语句）

break关键字的用法有常见的两种：
1.可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
2.还可以用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。
关于循环的选择，有一个小建议：
凡是次数确定的场景多用for循环；否则多用while循环。do-while循环使用稍微少一些。

public class Demo2Break {
    /*
    break : 终止循环体内容的执行
    注意：使用是基于条件控制的
    break语句只能在循环和switch中进行使用.
    
    需求: 模拟20岁工作到80岁, 60岁退休.
    */
    public static void main(String[] args) {
        for (int i = 20; i <= 80; i++) {
            if (i == 60) {
                break; // 结束整个循环
            }
            System.out.println(i + "岁正在上班");
        }
    }
}

public class Demo14Break {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
//如果希望从第4次开始，后续全都不要了，就要打断循环
            if (i == 4) {//如果当前是第4次
                break;//那么就打断整个循环
            }
            System.out.println("Hel10" + i);
        }
    }
}

7、循环控制_continue语句（跳转控制语句）

另一种循环控制语句是continue关键字。
一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。

public class Demo1Continue {
    /*
    continue : 跳过某次循环体内容的执行
    注意：使用是基于条件控制, 在循环内部使用.
    需求: 模拟电梯上行的过程 1-24层, 4层不停.
    */
    public static void main(String[] args) {
        for (int i = 1; i <= 24; i++) {
            if (i == 4) {
                continue;
            }
            System.out.println(i + "层到了~");
        }
    }
}

8、死循环

public class Loop {
/*
for死循环格式：
fox（;;）{
}

while死循环格式：
while（true）{
}

do..while死循环格式：
do{
}while(true)

问题: 死循环有应用场景吗?
例如: 键盘录入一个1-100之间的整数
顾虑: 键盘录入是用户操作的, 用户就可能会出现一些误操作的现象
*/

    public static void main(String[] args) {

        for (; ; ) {
            System.out.println("我停不下来了~");
        }

        while (true) {
            System.out.println("我停不下来了~");
        }

            do {
                System.out.println("我停不下来了~");
            } while (true);
            System.out.println("看看我能被执行吗?~"); // 无法访问的语句
        }
    }
}

public class Demol6DeadLoop {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; ) {//忘了写步进语句i++
            System.out.println("Hello" + i);//死循环例子
        }
    }
}

public class Demo16DeadLoop {
    public static void main(String[] args) {
        while (true) {
            System.out.print1n("I Love Java!");
        }
        //System.out.print1n("Helllo");//死循环没结束，后面写什么都运行不了
    }
}

import java.util.Scanner;

public class Test {
/*
需求：程序运行后，用户可多次查询星期对应的减肥计划，直到输入0，程序结束

步骤:
1. 不明确用户操作几次, 使用死循环包裹业务逻辑
2. 匹配到0的时候，使用break结束循环死循环
*/

    public static void main(String[] args) {
        lo:
        while (true) {
            System.out.println("请输入您要查看的星期数:");
            System.out.println("(如无需继续查看,请输入0退出程序)");

            // 1. 键盘录入星期数据，使用变量接收
            Scanner sc = new Scanner(System.in);
            int week = sc.nextInt();

            // 2. 多情况判断，采用switch语句实现
            switch (week) {
                // 3. 在不同的case中，输出对应的减肥计划
                case 0:
                    System.out.println("感谢您的使用");
                    break lo;
                case 1:
                    System.out.println("跑步");
                    break;
                case 2:
                    System.out.println("游泳");
                    break;
                case 3:
                    System.out.println("慢走");
                    break;
                case 4:
                    System.out.println("动感单车");
                    break;
                case 5:
                    System.out.println("拳击");
                    break;
                case 6:
                    System.out.println("爬山");
                    break;
                case 7:
                    System.out.println("好好吃一顿");
                    break;
                default:
                    System.out.println("您的输入有误");
                    break;
            }
        }
    }
}

9、嵌套循环

所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。
总共的循环次数=外循环次数*内循环次数

for(初始化表达式①; 循环条件②; 步进表达式⑦) {
for(初始化表达式③; 循环条件④; 步进表达式⑥) {
执行语句⑤;
}
}

大括号里完整地执行了一次，就认为是一次循环，不管括号里写什么！

public class Demo17LoopHourAndMinute {
    public static void main(String[] args) {
        for (int hour = 0; hour < 24; hour++) {//外层控制小时

            for (int minute = 0; minute < 60; minute++) {//内层控制小时之内的分钟
                System.out.println(hour + "点" + minute + "分");
            }
        }
    }
}

10、用循环求出1-100之间的偶数和

题目：求出1-100之间的偶数和。
思路：
1.既然范围已经确定了是1到100之间，那么我就从1、2、3.一直到100这么多数字一个一个进行检查。
2.总共有100个数字，并非所有数字部能用。必须要是偶数才能用，
判断（if语句）偶数：num % 2==0
3.需要一个变量，用来进行累加操作。也就好比是一个存钱罐。

public class Demo12HundredSum {
    public static void main(String[] args) {
        int sum = 0; //用来累加的存钱罐

        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {//如果是偶数
                sum += i;
            }
        }
        System.out.println("结果是：" + sum);//结果为2250
    }
}

11、Random

import java.util.Random;

public class Demo1Random {
/*
Random : 产生随机数
1. 导包 : import java.util.Random;
导包的动作必须出现在类定义的上面
2. 创建对象 : Random r = new Random();
上面这个格式里面，r 是变量名，可以变，其他的都不允许变
3. 获取随机数 : int number = r.nextInt(10); //获取数据的范围：[0,10) 包括0,不包括10
上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不允许变

需求: 产生随机数1-10之间的
*/

    public static void main(String[] args) {
        // 2. 创建对象
        Random r = new Random();
        for (int i = 1; i <= 10; i++) {
            // 3. 获取随机数
            int num = r.nextInt(10) + 1; // 1-10
            System.out.println(num);
        }
    }
}

11、猜数字

import java.util.Scanner;
import java.util.Random;

public class Test {
    /*
    需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
    当猜错的时候根据不同情况给出相应的提示
    如果猜的数字比真实数字大，提示你猜的数据大了
    如果猜的数字比真实数字小，提示你猜的数据小了
    如果猜的数字与真实数字相等，提示恭喜你猜中了
    
    1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
    2. 使用Random产生一个1-100之间的数, 作为要猜的数
    3. 键盘录入用户猜的的数据
    4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
    
    5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
    6. 猜对之后, break结束.
    */
    public static void main(String[] args) {
        // 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        // 2. 使用Random产生一个1-100之间的数, 作为要猜的数
        int randomNum = r.nextInt(100) + 1;

        //为了测试程序，可以先把随机数打印出来
        System.out.println(randomNum);

        // 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
        while (true) {
            // 3. 键盘录入用户猜的的数据
            System.out.println("请输入您猜的数据:");
            int num = sc.nextInt();
            // 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
            if (num > randomNum) {
                System.out.println("猜大了");
            } else if (num < randomNum) {
                System.out.println("猜小了");
            } else {
                // 6. 猜对之后, break结束.
                System.out.println("恭喜,猜中了");
                break;
            }
        }
        System.out.println("感谢您的使用");
        //加了break，这句话有可能执行到，如果不加break，这句话系统会认为绝对是执行不到的
    }
}