五：循环——让程序重复做事

一、回顾与本篇目标

上一篇你学会了条件判断——程序能根据不同情况做不同的事情了。你知道 if/else 做二选一，if/else if/else 做多选一，switch/case 适合判断一个变量等于几个固定值。

但条件判断只能让程序“选择走哪条路”，不能让它“反复走同一条路”。比如：打印 1 到 100 的所有数字、计算全班 50 个学生的平均分、让用户不断输入密码直到输入正确。这些需求都需要循环——让一段代码重复执行多次。

循环是编程中另一个核心控制结构。有了循环，你写几行代码就能处理成千上万条数据。不用循环的话，打印 1 到 100 你需要写 100 行 System.out.println()。

本篇的目标：

1. 掌握 for 循环——知道循环次数时使用
2. 掌握 while 循环——不知道循环次数时使用
3. 了解 do...while 循环——至少执行一次的循环
4. 学会 break 和 continue——控制循环的开关
5. 学会循环嵌套——循环里面套循环

二、为什么需要循环

先看一个没有循环的世界有多痛苦。假设你要在屏幕上打印 1 到 5：

// 没有循环：重复的代码
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);

5 个数字还能忍。如果要打印 1 到 100 呢？1 到 10000 呢？而且如果数字范围是运行时才确定的（比如用户输入一个数字 N，打印 1 到 N），你根本没办法提前写死那么多行代码。

用循环解决这个问题——只需要 3 行：

// 用循环：简洁且灵活
for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

把 5 换成 100，就能打印 1 到 100。换成 N，就能打印 1 到 N。代码量不变，只是改了一个数字。

三、for 循环——最常用的循环

for 循环适合你知道要重复多少次的情况。它的语法看起来有点复杂，但拆开之后非常清晰。

基本语法

for (初始化; 条件; 更新) {
    // 循环体：每次循环要执行的代码
}

括号里有三个部分，用分号隔开：

• 初始化：在循环开始前执行一次。通常用来创建一个循环计数器变量。
• 条件：每次循环开始前检查。如果为 true，执行循环体；如果为 false，结束循环。
• 更新：每次循环体执行完毕后执行。通常用来更新计数器（加 1 或减 1）。

执行流程——用具体例子理解

for (int i = 1; i <= 3; i++) {
    System.out.println("第 " + i + " 次循环");
}

这段代码的执行过程如下：

1. 初始化：int i = 1——创建变量 i，赋值为 1。这一步只在开始时执行一次。
2. 条件检查：i <= 3？1 <= 3 是 true，进入循环体。
3. 执行循环体：输出“第 1 次循环”。
4. 更新：i++——i 从 1 变成 2。
5. 条件检查：i <= 3？2 <= 3 是 true，再次进入循环体。
6. 执行循环体：输出“第 2 次循环”。
7. 更新：i++——i 从 2 变成 3。
8. 条件检查：i <= 3？3 <= 3 是 true，再次进入循环体。
9. 执行循环体：输出“第 3 次循环”。
10. 更新：i++——i 从 3 变成 4。
11. 条件检查：i <= 3？4 <= 3 是 false，结束循环。程序继续执行循环后面的代码。

输出：

第 1 次循环
第 2 次循环
第 3 次循环

for 循环的常见模式

// 模式一：从 0 开始计数（最常用，数组遍历就用这个）
for (int i = 0; i < 5; i++) {
    System.out.print(i + " ");  // 输出：0 1 2 3 4
}
System.out.println();

// 模式二：从 1 开始计数
for (int i = 1; i <= 5; i++) {
    System.out.print(i + " ");  // 输出：1 2 3 4 5
}
System.out.println();

// 模式三：递减
for (int i = 5; i >= 1; i--) {
    System.out.print(i + " ");  // 输出：5 4 3 2 1
}
System.out.println();

// 模式四：每次加 2
for (int i = 0; i <= 10; i += 2) {
    System.out.print(i + " ");  // 输出：0 2 4 6 8 10
}
System.out.println();

用 for 循环计算 1 到 100 的和

public class SumDemo {
    public static void main(String[] args) {
        int sum = 0;  // 用来累加结果

        for (int i = 1; i <= 100; i++) {
            sum = sum + i;  // 把当前的 i 加到 sum 上
        }

        System.out.println("1 到 100 的和是：" + sum);  // 5050
    }
}

关键理解：sum = sum + i 这行代码在每次循环时执行。第一次循环 i=1，sum 变成 1；第二次循环 i=2，sum 变成 3；第三次循环 i=3，sum 变成 6……循环结束后，sum 里存的就是 1+2+3+…+100 的结果。这种模式叫累加，是循环最经典的用法之一。

四、while 循环——不知道循环次数时使用

while 循环的逻辑更简单：只要条件成立，就一直执行循环体。 适合你不知道要循环多少次的场景——比如让用户一直输入，直到输入正确的密码。

基本语法

while (条件) {
    // 循环体：条件成立时反复执行
}

执行流程：

1. 检查条件。
2. 如果条件为 true，执行循环体，然后回到第 1 步。
3. 如果条件为 false，结束循环。

public class WhileDemo {
    public static void main(String[] args) {
        int count = 1;

        while (count <= 5) {
            System.out.println("第 " + count + " 次循环");
            count++;  // 别忘了更新条件变量！否则会死循环
        }

        System.out.println("循环结束");
    }
}

输出和前面的 for 循环一样——打印 5 次。

for 和 while 怎么选？

• 知道循环次数（比如遍历 0 到 9、遍历数组所有元素）→ 用 for。
• 不知道循环次数（比如等用户输入正确的值、读取文件直到末尾）→ 用 while。

while 循环的经典场景：密码验证

由于 Java 基础阶段还没有学如何从键盘读取输入，这里用模拟的方式展示逻辑：

public class PasswordDemo {
    public static void main(String[] args) {
        String correctPassword = "123456";
        String input = "000000";  // 模拟用户第一次输入的密码
        int attempts = 0;

        // 只要密码不对，就一直循环
        while (!input.equals(correctPassword)) {
            attempts++;
            System.out.println("第 " + attempts + " 次尝试：密码错误");

            // 模拟用户再次输入
            if (attempts >= 3) {
                input = "123456";  // 第 3 次终于输入正确
            }
        }

        System.out.println("密码正确！共尝试了 " + attempts + " 次。");
    }
}

输出：

第 1 次尝试：密码错误
第 2 次尝试：密码错误
第 3 次尝试：密码错误
密码正确！共尝试了 4 次。

注意：while 循环中必须有能改变条件的语句（比如 count++ 或更新输入值），否则条件永远为 true，循环永远不会结束——这叫死循环，程序会卡住不动。

五、do…while 循环——至少执行一次

do...while 和 while 的唯一区别是：先执行一次循环体，再检查条件。 这意味着循环体至少会被执行一次。

基本语法

do {
    // 循环体：先执行一次，然后根据条件决定是否继续
} while (条件);  // 注意：这里有一个分号！

public class DoWhileDemo {
    public static void main(String[] args) {
        int count = 10;  // 初始值就不满足条件

        do {
            System.out.println("当前 count = " + count);
            count++;
        } while (count <= 5);

        System.out.println("循环结束，count = " + count);
    }
}

输出：

当前 count = 10
循环结束，count = 11

即使 count 初始是 10（不满足 <= 5），循环体也执行了一次。这就是 do...while 的特点。

do…while 后面有一个分号——这是语法规定，忘记写会导致编译错误。

六、break 和 continue——循环控制开关

break：立即退出整个循环

在循环体中遇到 break，循环立即终止，程序继续执行循环后面的代码。

// 找到第一个能被 7 整除的数就停止
for (int i = 1; i <= 50; i++) {
    if (i % 7 == 0) {
        System.out.println("找到了：" + i);  // 7
        break;  // 立即退出循环
    }
    System.out.println(i + " 不是");
}

输出：

1 不是
2 不是
3 不是
4 不是
5 不是
6 不是
找到了：7

break 之后，循环就结束了，8 到 50 都不会被检查。

continue：跳过本轮，继续下一轮

在循环体中遇到 continue，本轮循环中 continue 后面的代码被跳过，直接进入下一轮循环。

// 只打印奇数，跳过偶数
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;  // 如果是偶数，跳过本轮剩下的代码
    }
    System.out.print(i + " ");
}

输出：1 3 5 7 9

break 和 continue 的区别：

• break：直接退出整个循环，就像按了“停止”按钮。
• continue：只跳过本轮循环，继续下一轮，就像按了“跳过”按钮。

七、循环嵌套——循环里面套循环

一个循环的循环体里可以再写一个循环——这就是嵌套循环。最经典的例子是打印乘法口诀表：

public class MultiplicationTable {
    public static void main(String[] args) {
        // 外层循环：控制行（1 到 9）
        for (int i = 1; i <= 9; i++) {
            // 内层循环：控制列（1 到 i）
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "×" + i + "=" + (i * j) + "\t");
            }
            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×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

嵌套循环的执行顺序：外层循环执行一次，内层循环要执行完整的一轮。外层 i=1 时，内层 j 从 1 到 1（执行 1 次）；外层 i=2 时，内层 j 从 1 到 2（执行 2 次）……依此类推。

\t 是制表符（Tab），让各列之间对齐。

八、综合演示：判断素数

素数（质数）是只能被 1 和自身整除的大于 1 的整数。下面这个程序用循环判断一个数是不是素数，综合运用了 for 循环、条件判断、break：

public class PrimeChecker {
    public static void main(String[] args) {
        int number = 17;  // 要判断的数字

        System.out.println("========== 素数判断 ==========");
        System.out.println("数字：" + number);

        boolean isPrime = true;  // 假设它是素数

        if (number <= 1) {
            isPrime = false;  // 1 和小于 1 的数不是素数
        } else {
            // 检查 2 到 number-1 之间是否有因子
            for (int i = 2; i < number; i++) {
                if (number % i == 0) {
                    System.out.println("找到了因子：" + i);
                    isPrime = false;
                    break;  // 找到因子就不再继续检查
                }
            }
        }

        if (isPrime) {
            System.out.println(number + " 是素数");
        } else {
            System.out.println(number + " 不是素数");
        }
        System.out.println("==============================");
    }
}

输出：

========== 素数判断 ==========
数字：17
17 是素数
==============================

把 number 改成 15，输出：

找到了因子：3
15 不是素数

九、本篇动手练习

练习 1：求 1 到 100 的奇数和与偶数和

新建 Practice5_1.java。用 for 循环分别计算 1 到 100 之间所有奇数的和、所有偶数的和。分别输出两个结果。

练习 2：打印乘法表

新建 Practice5_2.java。用嵌套循环打印 9×9 乘法口诀表（参考第七节的代码，自己敲一遍）。

练习 3：猜数字模拟

新建 Practice5_3.java。声明一个“目标数字”变量 int target = 42;。声明一个“猜测”变量 int guess = 1;。用 while 循环不断把 guess 增加 1，直到猜中目标数字。输出一共猜了多少次。

练习 4：打印菱形

新建 Practice5_4.java。用嵌套循环打印一个由星号组成的菱形图案。可以先打印一个正三角形（上半部分），再打印一个倒三角形（下半部分）。

十、本篇小结

这一篇你学会了让程序重复执行：

• for 循环：知道循环次数时使用。三个部分——初始化、条件、更新——用分号分隔。最常用的模式：for (int i = 0; i < n; i++)。
• while 循环：不知道循环次数时使用。只要条件成立就一直执行。必须确保循环体内有改变条件的语句，避免死循环。
• do...while 循环：和 while 类似，但至少执行一次。循环体在前，条件判断在后。while 后面要加分号。
• break：立即退出整个循环。常用于找到目标后提前结束。
• continue：跳过本轮循环的剩余代码，继续下一轮。常用于过滤不需要处理的情况。
• 循环嵌套：循环里面套循环。外层执行一次，内层执行完整一轮。

循环是编程中最强大的工具之一——几十行代码就能处理成千上万条数据。下一篇，我们学习数组——把多个相同类型的数据打包放在一起，用循环批量处理。

下一篇预告

下一篇——《数组——批量管理数据》：什么是数组、数组的声明和初始化、用索引访问数组元素、用循环遍历数组、二维数组、数组的常见操作。数组和循环是天生的搭档——数组存数据，循环处理数据。

Java 零基础入门，每周更新。