break 与 continue

"写循环很容易，写好循环很难。" —— 白歌在 Code Review 中看到小崔的嵌套循环代码后说道，"你需要精确控制循环的粒度——什么时候跳出、什么时候跳过、什么时候跳到哪里。break 和 continue 是你手中最锋利的两把手术刀，但用不好也会伤到自己。"

概述

在循环执行过程中，有时我们需要打破正常的迭代节奏：提前终止整个循环，或者跳过当前迭代直接进入下一轮。Java 提供了三个关键字来实现流程跳转：

关键字	作用	影响范围	类比
break	立即终止当前循环	当前循环（或标签指定的外层循环）	电影中途离场
continue	跳过当前迭代，进入下一轮	当前循环（或标签指定的外层循环）	快进跳过当前片段
return	退出整个方法	当前方法	离开电影院

一、break：终止循环

基本用法

break 语句用于立即终止最内层的循环（或 switch 语句）。程序跳转到循环体之后的第一条语句继续执行。

示例：在商品列表中查找目标

朱璐的库存模块需要在商品列表中查找第一个库存不足的商品并发出警告：

/**
 * 飞翔科技库存预警——break 提前终止循环
 */
public class StockAlert {
    public static void main(String[] args) {
        String[] products = {
            "手机", "电脑", "平板", "耳机", "手表", "音箱", "充电器"
        };
        int[] stock = {120, 85, 200, 5, 153, 45, 42};
        final int ALERT_THRESHOLD = 10; // 预警阈值

        System.out.println("===== 飞翔科技库存预警 =====");
        System.out.println("预警阈值：库存 < " + ALERT_THRESHOLD + " 件");
        System.out.println();

        boolean foundAlert = false;

        for (int i = 0; i < products.length; i++) {
            System.out.println("正在检查：" + products[i]
                + "（库存：" + stock[i] + "）");

            if (stock[i] < ALERT_THRESHOLD) {
                System.out.println();
                System.out.println("【警告】" + products[i]
                    + " 库存不足！仅剩 " + stock[i] + " 件！");
                System.out.println("请立即联系供应商补货。");
                foundAlert = true;
                break; // 找到第一个预警项后立即终止循环
            }
        }

        if (!foundAlert) {
            System.out.println();
            System.out.println("所有商品库存正常，无预警。");
        }

        System.out.println("库存检查完毕。");
    }
}

运行输出：
===== 飞翔科技库存预警 =====
预警阈值：库存 < 10 件

正在检查：手机（库存：120）
正在检查：电脑（库存：85）
正在检查：平板（库存：200）
正在检查：耳机（库存：5）

【警告】耳机 库存不足！仅剩 5 件！
请立即联系供应商补货。
库存检查完毕。

关键观察：循环在发现耳机库存不足后立即终止，后续的手表、音箱、充电器不再检查。如果你希望继续检查所有商品（报告所有预警项），则不应使用 break。

二、continue：跳过当前迭代

基本用法

continue 语句用于跳过当前迭代的剩余部分，直接进入下一轮迭代的条件判断。

for 循环 vs while 循环中的 continue

循环类型	continue 后的行为	风险
for	执行迭代语句（如 `i++`），然后判断条件	安全（迭代语句自动执行）
while	直接跳回条件判断	如果迭代逻辑在 continue 之后，会导致死循环

示例：过滤停产商品

飞翔科技电商平台需要生成在售商品报告，跳过已停产（库存为 0 或负数）的商品：

/**
 * 飞翔科技在售商品报告——continue 跳过
 */
public class ActiveProductReport {
    public static void main(String[] args) {
        String[] products = {
            "手机", "电脑", "平板", "耳机", "手表", "音箱", "充电器"
        };
        int[] stock = {120, -1, 200, 0, 153, 45, -1};
        // -1 表示已停产，0 表示售罄待补货

        System.out.println("===== 飞翔科技在售商品报告 =====");
        System.out.println();

        int activeCount = 0;

        for (int i = 0; i < products.length; i++) {
            // 跳过停产商品（stock 为负数）
            if (stock[i] < 0) {
                System.out.println("[跳过] " + products[i]
                    + " — 已停产，不在售");
                continue; // 跳过此商品，进入下一个
            }

            // 跳过售罄商品（stock 为 0）
            if (stock[i] == 0) {
                System.out.println("[跳过] " + products[i]
                    + " — 暂时售罄，待补货");
                continue;
            }

            // 在售商品
            activeCount++;
            String status = (stock[i] < 10) ? "（库存紧张！）" : "";
            System.out.println("[在售] " + products[i]
                + " — 库存：" + stock[i] + " 件" + status);
        }

        System.out.println();
        System.out.println("在售商品总数：" + activeCount + " 种");
        System.out.println("报告生成完毕。");
    }
}

运行输出：
===== 飞翔科技在售商品报告 =====

[在售] 手机 — 库存：120 件
[跳过] 电脑 — 已停产，不在售
[在售] 平板 — 库存：200 件
[跳过] 耳机 — 暂时售罄，待补货
[在售] 手表 — 库存：153 件
[在售] 音箱 — 库存：45 件
[跳过] 充电器 — 已停产，不在售

在售商品总数：4 种
报告生成完毕。

三、带标签的 break 与 continue（Labeled Break / Continue）

问题场景

在嵌套循环中，普通的 break 只能跳出最内层循环。如果需要在满足特定条件时跳出外层循环，该怎么办？

// 普通 break 只能跳出内层循环
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i * j > 10) {
            break; // 只跳出 j 循环，i 循环继续
        }
    }
}

解决方案：标签（Label）

Java 的标签语法允许你给循环命名，然后通过 break 标签 或 continue 标签 精确指定要跳转的目标循环：

标签名:
for / while / do-while (...) {
    for / while / do-while (...) {
        break 标签名;    // 跳出标签指定的循环
        continue 标签名; // 跳转到标签指定循环的下一轮迭代
    }
}

关键点

关键点	说明
标签命名	遵循 Java 标识符规则，通常用大写字母加下划线（如 `OUTER`）
标签位置	必须紧贴在目标循环语句之前
作用范围	只能用于循环（for/while/do-while），不能用于 if
跨层跳转	`break 标签` 跳转到标签所在循环的结束之后
继续迭代	`continue 标签` 跳转到标签所在循环的下一轮迭代

执行流程对比

示例：二维数组搜索

白歌为飞翔科技的学生管理系统写了高效的查找逻辑——在二维成绩表中查找第一个不及格的学生和科目：

/**
 * 飞翔科技成绩查找——带标签的 break
 * 在成绩二维表中找到第一个不及格成绩后完全停止搜索
 */
public class ScoreSearch {
    public static void main(String[] args) {
        String[] students = {"张三", "李四", "王五", "赵六"};
        String[] courses = {"Java基础", "数据结构", "数据库", "操作系统"};
        int[][] scores = {
            {88, 92, 79, 85},  // 张三：全部及格
            {76, 81, 55, 88},  // 李四：数据库 55 不及格 ← 第一个
            {45, 89, 93, 91},  // 王五：Java基础 45 不及格（不会被检查到）
            {60, 58, 72, 65}   // 赵六：有不及格（不会被检查到）
        };

        System.out.println("===== 飞翔科技成绩预警 =====");
        System.out.println("正在扫描成绩表，寻找第一个不及格记录...");
        System.out.println();

        boolean foundFailure = false;
        String failStudent = "";
        String failCourse = "";
        int failScore = 0;

        // OUTER 标签标记外层循环
        OUTER:
        for (int i = 0; i < students.length; i++) {
            System.out.println("→ 正在检查 " + students[i] + " 的成绩...");

            for (int j = 0; j < courses.length; j++) {
                System.out.println("    " + courses[j] + "：" + scores[i][j]);

                if (scores[i][j] < 60) {
                    foundFailure = true;
                    failStudent = students[i];
                    failCourse = courses[j];
                    failScore = scores[i][j];
                    break OUTER; // 跳出标签为 OUTER 的外层循环
                }
            }
        }

        System.out.println();
        if (foundFailure) {
            System.out.println("【预警】发现不及格记录：");
            System.out.println("  学生：" + failStudent);
            System.out.println("  科目：" + failCourse);
            System.out.println("  成绩：" + failScore + "（及格线：60）");
            System.out.println("已停止扫描，请及时跟进。");
        } else {
            System.out.println("所有学生全部及格，无预警。");
        }

        System.out.println("成绩扫描完毕。");
    }
}

运行输出：
===== 飞翔科技成绩预警 =====
正在扫描成绩表，寻找第一个不及格记录...

→ 正在检查 张三 的成绩...
    Java基础：88
    数据结构：92
    数据库：79
    操作系统：85
→ 正在检查 李四 的成绩...
    Java基础：76
    数据结构：81
    数据库：55

【预警】发现不及格记录：
  学生：李四
  科目：数据库
  成绩：55（及格线：60）
已停止扫描，请及时跟进。
成绩扫描完毕。

关键观察：break OUTER 直接跳出了外层 i 循环，王五和赵六的成绩完全没有被扫描。如果使用的是普通 break（不带标签），只会跳出内层 j 循环，然后继续扫描李四的剩余科目和王五、赵六的所有科目。

示例：带标签的 continue

大翔需要生成一份"问题学生报告"，跳过已经处理过的学生（标记为已谈话），继续处理下一个学生：

/**
 * 飞翔科技学生辅导跟踪——带标签的 continue
 */
public class StudentCounseling {
    public static void main(String[] args) {
        String[] students = {"张三", "李四", "王五", "赵六", "孙七"};
        boolean[] counseled = {true, false, false, true, false};
        // true = 已辅导过，需跳过

        System.out.println("===== 飞翔科技学生辅导跟踪 =====");
        System.out.println();

        PROCESS:
        for (int i = 0; i < students.length; i++) {
            if (counseled[i]) {
                System.out.println("[跳过] " + students[i]
                    + " — 已完成辅导，无需重复处理");
                continue PROCESS; // 跳转到下一个学生
            }

            System.out.println("--- 正在处理 " + students[i] + " ---");

            // 模拟多步骤辅导流程
            String[] steps = {"分析成绩", "制定计划", "座谈辅导", "记录归档"};
            for (int step = 0; step < steps.length; step++) {
                // 模拟：赵六拒绝座谈，后续步骤取消
                if (students[i].equals("赵六") && step == 2) {
                    System.out.println("  ✗ " + steps[step]
                        + "：学生拒绝，辅导中断");
                    // 这里用 break 跳出内层步骤循环，但外层继续下一个学生
                    // 所以我们用 continue PROCESS
                    System.out.println("  → 跳过剩余步骤，记录后处理下一个");
                    continue PROCESS;
                }
                System.out.println("  ✓ " + steps[step] + "：已完成");
            }

            // 标记为已处理
            counseled[i] = true;
            System.out.println("  → " + students[i] + " 辅导完成");
            System.out.println();
        }

        System.out.println("辅导跟踪完毕。");
    }
}

运行输出：
===== 飞翔科技学生辅导跟踪 =====

[跳过] 张三 — 已完成辅导，无需重复处理
--- 正在处理 李四 ---
  ✓ 分析成绩：已完成
  ✓ 制定计划：已完成
  ✓ 座谈辅导：已完成
  ✓ 记录归档：已完成
  → 李四 辅导完成

--- 正在处理 王五 ---
  ✓ 分析成绩：已完成
  ✓ 制定计划：已完成
  ✓ 座谈辅导：已完成
  ✓ 记录归档：已完成
  → 王五 辅导完成

[跳过] 赵六 — 已完成辅导，无需重复处理
--- 正在处理 孙七 ---
  ✓ 分析成绩：已完成
  ✓ 制定计划：已完成
  ✓ 座谈辅导：已完成
  ✓ 记录归档：已完成
  → 孙七 辅导完成

辅导跟踪完毕。

深度原理：break/continue 的字节码实现

普通 break 的字节码

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

反编译字节码（关键部分）：

 0: iconst_0
 1: istore_1              // i = 0
 2: iload_1
 3: bipush 10
 5: if_icmpge 29          // if i >= 10 goto 29（正常循环结束）
 8: iload_1
 9: iconst_5
10: if_icmpne 19          // if i != 5 goto 19
13: goto 29               // ← break：无条件跳转到偏移量 29（循环结束）
16: goto 21               // （编译器优化填充）
19: getstatic System.out
22: iload_1
23: invokevirtual println
26: iinc 1, 1
29: return

关键：break 被编译为一条 goto 指令，直接跳转到循环外的位置（偏移量 29）。

带标签 break 的字节码

带标签的 break（如 break OUTER）在字节码层面与普通 break 完全相同——都是一条 goto 指令，只是跳转的目标偏移量不同（指向外层循环的结束位置）。

普通 continue 的字节码

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue;
    }
    System.out.println(i);
}

反编译字节码（关键部分）：

...
10: if_icmpne 19          // if i != 5 goto 19（进入循环体）
13: goto 26               // ← continue：跳转到偏移量 26（迭代语句 iinc）
19: getstatic System.out
22: iload_1
23: invokevirtual println
26: iinc 1, 1             // ← continue 跳转目标：迭代语句仍会执行
29: goto 2                //   跳回条件判断

关键：continue 跳转的目标是迭代语句（iinc），而非条件判断——这保证了 for 循环中 continue 不会跳过迭代。

易错场景

反例一：while 循环中的 continue 导致死循环

// ❌ 错误：while 中 continue 跳过了迭代语句
int i = 0;
while (i < 10) {
    if (i == 5) {
        continue;  // 跳回 while 条件判断，但 i 始终为 5！
    }
    System.out.println(i);
    i++;  // ← 这行永远不会执行到
}
// 输出 0 1 2 3 4 之后进入死循环

// ✅ 方案一：将迭代操作放在 continue 之前
int i = 0;
while (i < 10) {
    i++; // 先递增
    if (i == 5) {
        continue;
    }
    System.out.println(i - 1);
}

// ✅ 方案二：用 for 循环（continue 后迭代语句仍会执行）
for (int j = 0; j < 10; j++) {
    if (j == 5) {
        continue;  // j++ 自动执行，安全
    }
    System.out.println(j);
}

反例二：标签位置错误

// ❌ 编译错误：标签必须紧贴循环语句
OUTER:
int x = 10; // 标签不能贴在变量声明上
for (int i = 0; i < 5; i++) {
    break OUTER; // 编译错误：undefined label: OUTER
}

// ✅ 正确：标签紧贴循环语句
int x = 10;
OUTER:
for (int i = 0; i < 5; i++) {
    break OUTER; // OK
}

反例三：break/continue 后的代码永远不执行

// ❌ 编译错误：unreachable statement
for (int i = 0; i < 5; i++) {
    if (i == 3) {
        break;
        System.out.println("不会执行"); // 编译错误！
    }
}

// ✅ 正确：break/continue 之后的语句不可达，应删除或调整逻辑
for (int i = 0; i < 5; i++) {
    if (i == 3) {
        System.out.println("即将退出");
        break;
    }
    System.out.println(i);
}

反例四：标签命名混乱

// ❌ 不推荐：标签名与变量名冲突，可读性极差
A:
for (int A = 0; A < 5; A++) {
    B:
    for (int B = 0; B < 5; B++) {
        if (A * B > 10) break A; // A 是标签还是变量？极度困惑！
    }
}

// ✅ 推荐：标签使用全大写加下划线，与变量名明显区分
OUTER:
for (int i = 0; i < 5; i++) {
    INNER:
    for (int j = 0; j < 5; j++) {
        if (i * j > 10) break OUTER;
    }
}

面试考点

Q1：break 和 continue 的本质区别是什么？字节码层面如何区分？

维度 break continue
行为终止整个循环跳过当前迭代
字节码 goto 跳到循环外 goto 跳到迭代语句（for）或条件判断（while）
后续迭代 不再执行继续执行
适用 switch 支持不支持
字节码层面两者都是 goto 指令，区别仅在于跳转的目标位置不同。

维度	break	continue
行为	终止整个循环	跳过当前迭代
字节码	`goto` 跳到循环外	`goto` 跳到迭代语句（for）或条件判断（while）
后续迭代	不再执行	继续执行
适用 switch	支持	不支持

Q2：带标签的 break/continue 和 goto 语句有什么区别？为什么 Java 保留了标签但没有 goto？

Java 保留了 goto 作为保留字（不能用作标识符），但不在语言中使用。标签 break/continue 是 Java 对 goto 的受限制替代方案：
goto：可以跳转到任意位置，极易写出意大利面条式代码
标签 break/continue：只能跳转到外围循环的特定位置，有限且安全
这种设计体现了 Java 在"灵活性"和"安全性"之间的权衡。

Q3：在 for 循环中，continue 之后迭代语句（如 i++）会执行吗？while 循环中呢？

for 循环：会执行。continue 跳转到迭代语句（i++），然后条件判断。
while/do-while 循环：不会执行（除非迭代语句在 continue 之前）。continue 直接跳回条件判断。
这是 for 循环的一个隐藏优势——continue 更安全。

Q4：如何在不使用 break 和 continue 的情况下实现相同的控制流？有什么优缺点？

可以通过以下方式实现：
// 使用 break 的版本
for (int i = 0; i < 10; i++) {
    if (found) break;
    // ...
}

// 不使用 break 的版本（引入标志位 + 条件合并）
boolean found = false;
for (int i = 0; i < 10 && !found; i++) {
    if (condition) {
        found = true;
    }
}
优缺点：
优点：代码逻辑更显式，在某些团队规范中更容易审查
缺点：引入额外的标志变量，条件复杂度增加，代码膨胀
结论：合理使用 break/continue 是更清晰的方案。Java 设计者提供了这些关键字，正说明它们有其价值。

Q5：switch 中的 break 和循环中的 break 有什么不同？

switch 中的 break：终止 switch 语句，防止 case 穿透。如果不写 break，执行会"穿透"到下一个 case。
循环中的 break：终止循环，程序跳转到循环体之后的第一条语句。
两者在字节码层面都是 goto 指令，只是跳转目标不同。它们是同一个关键字在不同上下文中的不同语义。

小结

要点	说明
break = 终止循环	立即跳出当前（或标签指定的）循环
continue = 跳过当前迭代	跳过循环体剩余部分，进入下一轮
for 中 continue 安全	迭代语句（如 i++）仍会执行
while 中 continue 危险	可能跳过迭代语句导致死循环
标签 = 有限制的 goto	只能跳转到外围循环，不能跳转到任意位置
标签命名用全大写	`OUTER`、`MAIN_LOOP`，与变量区分
字节码层面都是 goto	break 跳到循环外，continue 跳到迭代/条件