Java break 与 continue 语句

Begindev 编辑部 March 27, 2026

在 Java 中，break 和 continue 语句为你提供了控制循环执行的强大能力。它们允许你改变 for、while 和 do-while 循环的标准执行流程，让你能够根据特定条件直接跳过某次迭代，或者干脆彻底退出整个循环。

1. break 语句

break 语句用于提前终止一个循环。当程序在循环内部遇到 break 语句时，该循环的执行会被立即强行停止，程序的控制权会直接转移到循环体之后的下一行代码。

1.1 基础用法

break 最常见的应用场景是：当满足某个特定条件时，立刻退出循环。请看下面的例子：

public class BreakExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                break; // 当 i 等于 5 时，直接退出循环
            }
            System.out.println("i = " + i);
        }
        System.out.println("循环已结束。");
    }
}

代码解析：

我们初始化了一个 for 循环，打算从 1 迭代到 10。
在循环内部，我们用一个 if 语句检查 i 是否等于 5。
当 i 变成 5 的那一刻，break 语句被触发执行。
break 语句立刻杀死了这个循环。
程序接着执行循环外面的下一行代码，打印出 "循环已结束。"。

程序的输出将会是：

i = 1
i = 2
i = 3
i = 4
循环已结束。

请注意，当 i 达到 5 时循环就停止了，后续的 5 到 10 的迭代被全部跳过。

1.2 嵌套循环中的 break (带标签的 break)

当你处理嵌套循环（一个循环里面套着另一个循环）时，普通的 break 语句只会终止包含它的最内层循环。如果你想从内层循环直接“破壳而出”跳出外层循环，你需要使用带标签的 (labeled) break 语句。

public class NestedBreakExample {
    public static void main(String[] args) {
        outerLoop: // 为外层循环定义一个标签，名字叫 outerLoop
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    break outerLoop; // 直接跳出名为 outerLoop 的外层循环
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
        System.out.println("嵌套循环已结束。");
    }
}

代码解析：

我们有两层嵌套的 for 循环。外层和内层都计划从 1 迭代到 3。
我们给外层循环贴了一个标签，命名为 outerLoop。
在内层循环中，我们检查：如果 i 是 2 且 j 也是 2。
当条件满足时，执行 break outerLoop;。这行指令告诉程序直接打断并跳出那个贴着 outerLoop 标签的循环。
结果就是，当 i 为 2 且 j 为 2 时，内外两层循环同时被终结，程序直接去打印 "嵌套循环已结束。"。

程序的输出将会是：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
嵌套循环已结束。

如果没有这个标签（只写 break;），那么当 i=2, j=2 时，仅仅只是内层循环被终止，外层循环依然会继续推进到 i=3 的那一轮。

2. continue 语句

continue 语句用于跳过当前这一次迭代的剩余代码，并直接飞奔去开启循环的下一次迭代。与 break 彻底杀死整个循环不同，continue 只是说：“这次算了吧，我们直接开始下一轮”。

2.1 基础用法

当你只想基于特定条件避开循环体内的某些操作时，continue 非常有用。

public class ContinueExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue; // 遇到偶数，跳过本次循环剩余代码，直接进入下一轮
            }
            System.out.println("i = " + i);
        }
        System.out.println("循环已结束。");
    }
}

代码解析：

我们有一个从 1 到 10 的 for 循环。
在循环内，我们使用取模运算符 (%) 来检查 i 是否是偶数。
如果 i 是偶数，continue 语句被触发。
continue 会直接跳过后面的 System.out.println 代码。
循环接着进入下一轮迭代（比如从 i=2 变成 i=3）。

程序的输出将会是：

i = 1
i = 3
i = 5
i = 7
i = 9
循环已结束。

你可以看到，所有的偶数 (2, 4, 6, 8, 10) 都没有被打印出来，只有奇数被输出了。

2.2 嵌套循环中的 continue (带标签的 continue)

和 break 类似，continue 默认也只作用于最内层循环。如果你想在内层循环中，强制外层循环直接进入下一轮，你可以使用带标签的 continue。

public class NestedContinueExample {
    public static void main(String[] args) {
        outerLoop: // 为外层循环定义标签
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    continue outerLoop; // 中断内层当前操作，强制外层循环进入下一轮
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
        System.out.println("嵌套循环已结束。");
    }
}

代码解析：

外层循环被打上了 outerLoop 标签。
在内层循环里，当 i 是 2 且 j 是 2 时，触发 continue outerLoop;。
这行代码告诉程序：立刻停止当前内层循环的所有动作，直接跳到贴着 outerLoop 标签的外层循环，并让外层循环开始它的下一次迭代。

程序的输出将会是：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3
嵌套循环已结束。

注意观察，当 i 是 2 时，j=1 被正常打印。但本来应该打印 j=2 时，触发了标签 continue，程序直接抛弃了当时内层循环剩下的步骤，直接让外层循环推进到了 i = 3。

3. 实战案例演示

3.1 过滤无效数据 (使用 continue)

假设你正在处理一份用户 ID 列表，你只想处理正数 ID，跳过那些小于等于 0 的异常 ID。

public class ProcessUserIds {
    public static void main(String[] args) {
        int[] userIds = {101, -5, 205, 0, 302, -1, 400};
        
        for (int userId : userIds) {
            if (userId <= 0) {
                continue; // 跳过无效的用户 ID，不予处理
            }
            System.out.println("正在处理用户 ID: " + userId);
            // 假设这里有一些处理用户的复杂逻辑...
        }
        System.out.println("用户 ID 处理完毕。");
    }
}

通过使用 continue，无效的 ID (-5, 0, -1) 会被直接忽略，只有合法的正数 ID 会被打印和处理。

3.2 查找目标元素 (使用 break)

另一个经典的场景是：在一个数组中搜索特定目标，一旦找到，就没有必要再检查剩下的元素了。

public class SearchArray {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int target = 30;
        boolean found = false; // 用于标记是否找到了目标
        
        for (int number : numbers) {
            System.out.println("正在检查数字: " + number);
            if (number == target) {
                found = true;
                break; // 找到了！立马退出循环，节省性能
            }
        }
        
        if (found) {
            System.out.println("成功在数组中找到了目标: " + target);
        } else {
            System.out.println("数组中不存在目标: " + target);
        }
    }
}

当程序检查到 30 时，found 被设为 true，随后 break 触发退出循环。因此，控制台根本不会打印“正在检查数字: 40”或 50。