Java 循环结构：for、while、do-while 的区别

循环结构是编程中最常用的控制语句之一，它允许我们重复执行一段代码，直到满足特定条件。Java 提供了三种循环结构：for、while 和 do-while。理解它们的区别和适用场景，能够帮助你写出更简洁、更高效的代码。

一、for 循环：已知循环次数的首选

for 循环是三种循环中语法最紧凑的，适用于循环次数明确的场景。它将初始化、条件判断和迭代操作集中在一行代码中，代码结构非常清晰。

基本语法

for (初始化表达式; 条件表达式; 迭代表达式) {
    // 循环体
}

执行流程

1. 执行初始化表达式（仅执行一次）
2. 判断条件表达式，如果为 true，则执行循环体；如果为 false，循环结束
3. 执行循环体后，自动执行迭代表达式
4. 回到步骤 2，重复判断和执行

典型用法

// 遍历数组
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    System.out.println("第 " + (i + 1) + " 个元素: " + numbers[i]);
}

// 遍历集合（更简洁的方式）
List<String> names = Arrays.asList("张三", "李四", "王五");
for (String name : names) {
    System.out.println("姓名: " + name);
}

核心特点

• 循环次数确定：当你知道需要循环多少次时，for 循环是最自然的选择
• 作用域控制：循环变量 i 的作用域仅限于循环内部，不会污染外部命名空间
• 语法紧凑：初始化、条件和迭代写在一起，代码一目了然

二、while 循环：条件驱动，灵活可控

while 循环在循环次数不确定，但终止条件明确的场景下非常好用。它只包含一个条件判断，结构比 for 循环更简单。

基本语法

while (条件表达式) {
    // 循环体
}

执行流程

1. 判断条件表达式，如果为 true，则执行循环体；如果为 false，直接跳过循环
2. 执行循环体后，回到步骤 1 再次判断条件
3. 重复步骤 1 和 2，直到条件为 false

典型用法

// 用户输入验证
Scanner scanner = new Scanner(System.in);
int input;
System.out.println("请输入 1-100 之间的数字:");
while ((input = scanner.nextInt()) < 1 || input > 100) {
    System.out.println("输入无效，请重新输入 1-100 之间的数字:");
}
System.out.println("你输入的是: " + input);

// 读取文件直到结束
BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
String line;
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}
reader.close();

核心特点

• 先判断后执行：如果第一次条件就不满足，循环体一次都不会执行
• 条件灵活：条件可以是任意布尔表达式，不局限于计数器
• 需要手动控制：迭代逻辑必须写在循环体内部，需要开发者自己确保循环能够终止

三、do-while 循环：至少执行一次

do-while 循环与 while 循环的最大区别在于：它会先执行循环体，再判断条件。这意味着，无论条件是否满足，循环体至少会执行一次。

基本语法

do {
    // 循环体
} while (条件表达式);

执行流程

1. 直接执行循环体
2. 判断条件表达式，如果为 true，则回到步骤 1 继续执行；如果为 false，循环结束
3. 重复步骤 1 和 2，直到条件为 false

典型用法

// 菜单系统，至少显示一次菜单
Scanner scanner = new Scanner(System.in);
int choice;
do {
    System.out.println("\n===== 主菜单 =====");
    System.out.println("1. 查看用户");
    System.out.println("2. 添加用户");
    System.out.println("3. 删除用户");
    System.out.println("0. 退出系统");
    System.out.print("请选择操作: ");
    choice = scanner.nextInt();

    switch (choice) {
        case 1: System.out.println("查看用户功能"); break;
        case 2: System.out.println("添加用户功能"); break;
        case 3: System.out.println("删除用户功能"); break;
        case 0: System.out.println("退出系统"); break;
        default: System.out.println("无效选择");
    }
} while (choice != 0);

// 输入验证（至少让用户输入一次）
String password;
do {
    System.out.print("请设置密码: ");
    password = scanner.next();
} while (password.length() < 6);

核心特点

• 保证执行一次：循环体至少执行一次，适用于"先做后判断"的场景
• 后判断结构：条件判断在循环体之后，先干活再检查
• 分号结尾：while 后面必须带分号 ;，这是容易忽略的语法细节

四、三者对比总结

下面用表格清晰展示三种循环的核心区别：

执行流程图示

for/while:     判断条件 → 假 → 结束
                         ↓ 真
                      执行循环体
                         ↓
                      判断条件（循环）

do-while:     执行循环体
                         ↓
              判断条件 → 真 → 执行循环体
                         ↓ 假
                         ↓
                       结束

五、如何选择合适的循环

根据不同的场景，选择最适合的循环结构能让代码更清晰、更易维护。

1. 优先选择 for 循环的情况

当需要遍历数组或集合时，for 循环是最自然的选择。特别是使用增强 for 循环（foreach），代码简洁度极高：

// 推荐：增强 for 循环遍历集合
for (Object item : collection) {
    process(item);
}

// 推荐：带索引的 for 循环
for (int i = 0; i < list.size(); i++) {
    System.out.println("索引 " + i + " 的值: " + list.get(i));
}

2. 优先选择 while 循环的情况

当循环条件不依赖计数器，而是依赖外部状态时，while 循环更合适：

// 推荐：根据外部条件控制循环
while (!database.isConnected()) {
    System.out.println("等待数据库连接...");
    Thread.sleep(1000);
}

// 推荐：不定次数的搜索
while (!searchResult.matchesCriteria() && !searcher.isExhausted()) {
    searcher.findNext();
}

3. 优先选择 do-while 循环的情况

当需要确保至少执行一次时，必须使用 do-while：

// 推荐：菜单系统必须显示一次
do {
    displayMenu();
    choice = getUserInput();
} while (choice != EXIT);

// 推荐：用户交互场景
do {
    response = askUserQuestion();
} while (!response.isValid());

六、常见陷阱与注意事项

1. 死循环

死循环是最常见的错误，循环条件永远为 true 会导致程序卡死：

// 错误示例：死循环
int i = 0;
while (i < 10) {
    System.out.println(i);
    // 忘记 i++，导致 i 永远为 0
}

// 正确示例
int i = 0;
while (i < 10) {
    System.out.println(i);
    i++;  // 不要忘记迭代
}

2. for 与 while 的选择混淆

在可以互相替换时，选择更符合直觉的那个：

// 功能等价的两种写法
for (int i = 0; i < 5; i++) { }    // 更推荐：明确知道循环 5 次
int i = 0;
while (i < 5) { i++; }             // 也可以，但 for 更清晰

3. do-while 的分号遗漏

do-while 后面的分号容易遗漏：

// 错误：缺少分号
do {
    System.out.println("Hello");
} while (condition)  // 编译错误

// 正确：加分号
do {
    System.out.println("Hello");
} while (condition);

4. 循环变量的作用域

for 循环中定义的变量作用域更限定，避免命名冲突：

// for 循环的 i 作用域仅在循环内
for (int i = 0; i < 10; i++) { }
System.out.println(i);  // 编译错误：找不到 i

// while 循环的 i 在外部定义，可能影响后续代码
int i = 0;
while (i < 10) { i++; }
System.out.println(i);  // 输出 10

七、实战：综合运用三种循环

下面通过一个完整的示例，展示如何在实际代码中选择合适的循环：

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

        // 场景 1：处理已知数量的学生成绩（使用 for）
        System.out.print("请输入学生人数: ");
        int studentCount = scanner.nextInt();
        double[] scores = new double[studentCount];

        for (int i = 0; i < studentCount; i++) {
            System.out.print("请输入第 " + (i + 1) + " 个学生的成绩: ");
            scores[i] = scanner.nextDouble();
        }

        // 场景 2：验证输入直到合法（使用 while）
        double average;
        while (true) {
            System.out.print("请输入及格线 (0-100): ");
            double passLine = scanner.nextDouble();
            if (passLine >= 0 && passLine <= 100) {
                // 计算及格人数
                int passCount = 0;
                for (int i = 0; i < scores.length; i++) {
                    if (scores[i] >= passLine) {
                        passCount++;
                    }
                }
                average = passCount * 100.0 / studentCount;
                System.out.println("及格率: " + average + "%");
                break;
            }
            System.out.println("及格线必须在 0-100 之间，请重新输入。");
        }

        // 场景 3：菜单系统（使用 do-while）
        int choice;
        do {
            System.out.println("\n===== 成绩管理系统 =====");
            System.out.println("1. 显示所有成绩");
            System.out.println("2. 统计及格率");
            System.out.println("3. 查找最高分和最低分");
            System.out.println("0. 退出系统");
            System.out.print("请选择: ");
            choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    for (int i = 0; i < scores.length; i++) {
                        System.out.printf("学生 %d: %.1f 分%n", i + 1, scores[i]);
                    }
                    break;
                case 2:
                    System.out.println("及格率: " + average + "%");
                    break;
                case 3:
                    double max = scores[0], min = scores[0];
                    for (int i = 1; i < scores.length; i++) {
                        if (scores[i] > max) max = scores[i];
                        if (scores[i] < min) min = scores[i];
                    }
                    System.out.printf("最高分: %.1f, 最低分: %.1f%n", max, min);
                    break;
                case 0:
                    System.out.println("感谢使用，再见！");
                    break;
                default:
                    System.out.println("无效选项");
            }
        } while (choice != 0);

        scanner.close();
    }
}

在这个示例中：

• for 循环用于处理固定数量的学生成绩输入和遍历
• while 循环用于验证用户输入，直到得到合法值
• do-while 循环用于实现菜单系统，确保菜单至少显示一次

总结

Java 的三种循环结构各有特点：for 循环适合已知次数的场景，while 循环适合条件驱动的场景，do-while 循环适合至少执行一次的场景。选择合适的循环不仅能让代码更清晰，也能避免很多常见的逻辑错误。记住这个简单的原则：知道循环几次用 for，看情况循环用 while，必须执行一次用 do-while。