for 循环结构 :

说明 : for循环语句是常用的循环语句, 一般用在 循环次数已知 的情况下。

语法格式 :
    for (initialication; condition; increment) {
        statements;
    }
   
    for (初始化语句; 循环条件; 循环增量) {
        执行语句;
    }



1. for循环练习 :
练习 : 使用 for 循环, 求 1 ~ 100 之间的所有整数累加和.
    public class ForDemo4 {
            public static void main(String[] args) {
                    
                    // 1. 定义一个 `框变量`
                    int sum = 0;
                    
                    // 2. 遍历 1~100 之间的所有整数
                    for (int i = 1; i <= 100; i++) {
                            // 3. 将当前遍历的数值累加到框变量中
                            sum += i;
                    }
                    
                    // 4. 查看框变量中的数值
                    System.out.println("sum = " + sum);
            }
    }


2. for 循环嵌套
循环嵌套 是指在一个循环语句的循环体中再定义一个循环语句的语法结构, 类似于 大圈套小圈.
循环嵌套的特点 : 外层每循环一次, 内层循环就会执行 所有次.

    public class CircleDemo5 {
            public static void main(String[] args) {
                    
                    // 1. 定义一个 `计算器` 变量
                    int count = 0;
                    
                    // 2. 循环嵌套
                    for (int i = 0; i < 10; i++) {
                            for (int j = 0; j < 10; j++) {
                                    // 在内层循环中, 累加计数器变量
                                    count++;
                            }
                    }
                    
                    // 3. 查看计算器变量的数值
                    System.out.println("count = " + count);
            }
    }

输出结果为 : 100

3. for循环嵌套案例
地球和太阳的故事 地球是围绕着太阳转的, 每转完一圈是一年.(公转), 但是地球绕着太阳转的同时, 自己也在转, 转一圈是一天.(自转) 因此, 当地球完成一次公转同时,那么地球就完成了365次的自转.


    public class EarthDemo6 {
            public static void main(String[] args) {
                    
                    // 外层循环代表 `公转`
                    for (int i = 1; i <= 1; i++) {
                            // 内层循环代表 `自转`
                            for (int j = 1; j <= 365; j++) {
                                    System.out.println("地球完成了第"+j+"次自转.");
                            }
                            System.out.println("地球完成了第"+i+"次公转.");
                    }
                    
            }
    }
使用场景说明 : 如果说我们要完成一件事情的同时, 需要让另一件事情完成所有次, 这个时候我们就可以使用嵌套循环.


4. while 循环
while 循环语法格式 :
    while (condition) {
        statements;
    }
说明 :  while 循环一般使用在循环次数未知的场景下.
穷举 : 一个一个试, 效率最低, 也是最笨的方式.
案例 : 有一个人买了一筐鸡蛋, 至少有两个, 两个两个数, 多一个, 三个三个数, 也多一个, 四个四个数, 还是多一个, 请问: 至少有几个鸡蛋 ?
    public class WhileDemo7 {
            public static void main(String[] args) {
                    
                    // 1. 定义最少个数的鸡蛋数量
                    int egg = 2;
                    
                    // 2. while 死循环
                    while (true) {
                           
                            // 3. 判断, 当前的鸡蛋个数是否满足需求
                            if (egg % 2 == 1 && egg % 3 == 1 && egg % 4 == 1) {
                                    
                                    // 4. 一旦条件成立, 输出鸡蛋的最少个数
                                    System.out.println("egg = " + egg);
                                    
                                    // 5. 使用break跳出循环
                                    break;
                            }
                           
                            // 6. 每判断完毕一次, 就需要修改鸡蛋的个数, 继续循环
                            egg++;
                    }
            }
    }

5. do-while 循环
do-while循环和while循环的区别 :
1. 如果条件成立, 两者之间没有任何区别.
2. 如果条件不成立. while循环一次都不会执行, do-while循环会 至少 执行一次, 甚至可能由于那一次条件成立, 造成程序的死循环.

    public class DoWhileDemo8 {
            public static void main(String[] args) {
                  
                    int x = 10;
                    while (x > 10) {
                            System.out.println("小心翼翼 while 循环 : x = " + x);
                            x++;
                    }
               
                    int y = 10;
                    do {
                            System.out.println("先斩后奏 do-while 循环 : y = " + y);
                            y++;        // 造成死循环. 不安全, 一定要小心
                    } while (y > 10);
            }
    }

执行流程图解 :

我来占层楼啊