Java 循环结构 - for, while 及 do...while

Java 循环结构

Java 中的循环结构是一种控制流语句，用于在满足特定条件时重复执行某段代码。

循环结构能够有效地减少代码冗余，提高程序的执行效率，特别适用于需要重复执行相同或相似操作的场景。

通过循环，程序员可以简洁地表达重复性任务，而不必手动编写大量重复的代码。

✅ Java 提供了四种主要的循环结构：

• while循环：用于处理条件驱动的数学运算，特别是当循环次数不确定但需要满足特定条件时
• do-while循环：用于必须至少执行一次的数学运算
• for循环：用于处理已知循环次数的数学运算
• 增强for循环 (for-each 循环)：用于增强for循环专门为遍历数组和集合设计，使代码更简洁

---

Java while 循环

while 循环最适合处理条件驱动的数学运算，特别是当循环次数不确定但需要满足特定条件时。

✅ 下面是使用while循环完成 1+2+3+...+100 累加的实例：

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        int num = 1;
        while(sum <= 100) {
            sum += num;
            num++;
        }
        System.out.println("最终和：" + sum);
    }
}

💻 运行结果：

最终和：5050

---

Java do-while 循环

do-while 循环是 Java 中的一种后测试循环结构，它会先执行循环体中的代码，然后再检查循环条件。

这意味着循环体至少会执行一次，即使条件一开始就不满足。

✅ 下面是使用do-while循环实现的猜数字游戏实例：

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

public class GuessNumberGame {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();

        // 生成1-100的随机数
        int secretNumber = random.nextInt(100) + 1;
        int guess;
        int attempts = 0;

        System.out.println("欢迎来到猜数字游戏！");

        do {
            System.out.print("请输入你猜的数字(1-100): ");
            guess = scanner.nextInt();
            attempts++;

            if (guess < secretNumber) {
                System.out.println("太小了！");
            } else if (guess > secretNumber) {
                System.out.println("太大了！");
            }
        } while (guess != secretNumber);

        System.out.println("恭喜你猜对了！用了 " + attempts + " 次尝试。");
        scanner.close();
    }
}

💻 运行结果：

欢迎来到猜数字游戏！
请输入你猜的数字(1-100): 50
太大了！
请输入你猜的数字(1-100): 25
太小了！
请输入你猜的数字(1-100): 37
太大了！
请输入你猜的数字(1-100): 31
恭喜你猜对了！用了 4 次尝试。

---

Java for 循环

for循环用于在已知循环次数的情况下重复执行代码块。

for循环需要初始化循环控制变量、指定循环次数、迭代循环控制变量。

✅ 下面是使用for循环实现的九九乘法表实例：

public class MultiplicationTable {
    public static void main(String[] args) {
        // 外层循环控制行数（1-9）
        for (int i = 1; i <= 9; i++) {
            // 内层循环控制每行的列数
            for (int j = 1; j <= i; j++) {
                // 格式化输出乘法算式
                System.out.printf("%d×%d=%-2d  ", j, i, i * j);
            }
            // 每行结束后换行
            System.out.println();
        }
    }
}

💻 运行结果：

1×1=1
1×2=2   2×2=4
1×3=3   2×3=6   3×3=9
1×4=4   2×4=8   3×4=12  4×4=16
1×5=5   2×5=10  3×5=15  4×5=20  5×5=25
1×6=6   2×6=12  3×6=18  4×6=24  5×6=30  6×6=36
1×7=7   2×7=14  3×7=21  4×7=28  5×7=35  6×7=42  7×7=49
1×8=8   2×8=16  3×8=24  4×8=32  5×8=40  6×8=48  7×8=56  8×8=64
1×9=9   2×9=18  3×9=27  4×9=36  5×9=45  6×9=54  7×9=63  8×9=72  9×9=81  

---

Java 增强 for 循环 (for-each 循环)

Java 的增强 for 循环（也称为 for-each 循环）是 Java 5 引入的一种简化版的迭代语法。

它用于遍历数组和集合元素，使代码更简洁易读。

✅ 下面是使用for-each循环实现的九九乘法表实例：

public class MultiplicationTable {
    public static void main(String[] args) {
        // 创建一个包含1-9的数组
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};

        // 外层增强 for 循环控制行数（1-9）
        for (int i : numbers) {
            // 内层增强 for 循环控制每行的列数
            for (int j : numbers) {
                if (j <= i) {
                    // 格式化输出乘法算式
                    System.out.printf("%d×%d=%-2d  ", j, i, i * j);
                }
            }
            // 每行结束后换行
            System.out.println();
        }
    }
}

💻 运行结果：

1×1=1
1×2=2   2×2=4
1×3=3   2×3=6   3×3=9
1×4=4   2×4=8   3×4=12  4×4=16
1×5=5   2×5=10  3×5=15  4×5=20  5×5=25
1×6=6   2×6=12  3×6=18  4×6=24  5×6=30  6×6=36
1×7=7   2×7=14  3×7=21  4×7=28  5×7=35  6×7=42  7×7=49
1×8=8   2×8=16  3×8=24  4×8=32  5×8=40  6×8=48  7×8=56  8×8=64
1×9=9   2×9=18  3×9=27  4×9=36  5×9=45  6×9=54  7×9=63  8×9=72  9×9=81

---

Java break 关键字

break 是 Java 中的一个控制流关键字，主要用于提前终止循环语句或switch语句的执行。

break 执行跳出最近的一层循环（比如：多层循环嵌套的场景），将继续执行该循环后面的语句。

✅ 下面是使用break语句实现的查找数组中偶数实例：

public class ForEachBreakExample {
    public static void main(String[] args) {
        // 定义一个整数数组
        int[] numbers = {1, 3, 5, 8, 7, 10, 12};

        System.out.println("开始查找数组中的第一个偶数...");

        // 使用 for-each 循环遍历数组
        for (int num : numbers) {
            System.out.println("当前检查的数字: " + num);

            // 检查是否为偶数
            if (num % 2 == 0) {
                System.out.println("找到的第一个偶数是: " + num);
                break; // 找到后立即退出循环
            }
        }

        System.out.println("查找结束");
    }
}

💻 运行结果：

开始查找数组中的第一个偶数...
当前检查的数字: 1
当前检查的数字: 3
当前检查的数字: 5
当前检查的数字: 8
找到的第一个偶数是: 8
查找结束

---

Java continue 关键字

continue 是 Java 中的一个控制流关键字，作用是跳过当前循环的剩余部分，直接进入下一次循环的迭代。

✅ 下面是使用continue实现的统计 1-100 奇数的和实例：

public class ContinueExample2 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数
            }
            sum += i;
        }
        System.out.println("1-100奇数的和为: " + sum);
    }
}

💻 运行结果：

1-100奇数的和为: 2500

---

---