continue 是 Java 中的一个关键字，属于流程控制语句，它的作用是跳过当前循环体中剩余的语句，立即进入下一次循环。

你可以把它想象成在跑步比赛中，你跑了一圈，但跑到半路发现鞋带松了，于是你停下来系好鞋带，然后继续跑下一圈,而不是重新跑当前这一圈。

continue 的基本工作原理

continue 只能用在 for、while、do-while 循环中。

当程序执行到 continue 语句时：

1. 立即终止当前这一次循环的执行。
2. 跳过循环体中 continue 语句之后的所有代码。
3. 直接跳转到循环的更新条件部分（对于 for 循环）或循环条件判断部分（对于 while 和 do-while 循环）,开始下一次循环。

continue 在不同循环中的具体表现

a) 在 for 循环中

在 for 循环中，continue 会跳过当前迭代，然后执行for 循环的第三部分（迭代语句 i++）,接着判断循环条件。

示例： 打印 1 到 10 之间，除了 5 以外的所有数字。

public class ContinueExampleFor {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            // i 是 5，就跳过本次循环的剩余部分
            if (i == 5) {
                continue;
            }
            // 这行代码在 i == 5 时不会被执行
            System.out.println("i = " + i);
        }
    }
}

执行流程分析：

1. i = 1: 条件 1 <= 10 为真。if (1 == 5) 为假，打印 i = 1。
2. i = 2: ... 打印 i = 2。
3. i = 3: ... 打印 i = 3。
4. i = 4: ... 打印 i = 4。
5. i = 5: 条件 5 <= 10 为真。if (5 == 5) 为真，执行 continue。
   • 跳过 System.out.println(...)。
   • 直接执行 i++ (i 变为 6)。
   • 判断循环条件 6 <= 10。
6. i = 6: ... 打印 i = 6。
7. ... 以此类推，直到 i = 10 打印，i++ 变为 11,循环结束。

输出结果：

i = 1
i = 2
i = 3
i = 4
i = 6
i = 7
i = 8
i = 9
i = 10

b) 在 while 循环中

在 while 循环中，continue 会跳过当前迭代，然后直接跳转到循环条件判断部分。

示例： 实现与上面 for 循环相同的功能。

public class ContinueExampleWhile {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 10) {
            if (i == 5) {
                // 跳过本次循环，直接跳转到 while (i <= 10) 的判断
                i++; // 注意：这里必须手动增加 i，否则会造成死循环！
                continue;
            }
            System.out.println("i = " + i);
            i++;
        }
    }
}

特别注意： 在 while 或 do-while 循环中，continue 语句在修改循环变量的代码之前，if 条件成立，那么循环变量将不会被更新，导致下一次循环条件依然为真，从而造成无限循环。

下面这个代码是错误的：

// 错误示例，会导致死循环
int i = 1;
while (i <= 10) {
    if (i == 5) {
        continue; // 跳过后，i 永远不会被更新，i 始终为 5
    }
    System.out.println("i = " + i);
    i++;
}

在 while 循环中使用 continue 时，一定要确保循环变量在 continue 之前或之后被正确更新,以避免死循环。

c) 在 do-while 循环中

do-while 的情况与 while 类似。continue 会跳过剩余代码，然后直接跳转到循环条件判断部分。

public class ContinueExampleDoWhile {
    public static void main(String[] args) {
        int i = 1;
        do {
            if (i == 5) {
                i++; // 同样需要手动更新
                continue;
            }
            System.out.println("i = " + i);
            i++;
        } while (i <= 10);
    }
}

带标签的 continue (Labeled continue)

这是 continue 更高级的用法，用于跳出嵌套循环中的内层循环，直接跳转到外层循环的下一次迭代。

语法： continue outerLoopLabel;

就是一个合法的 Java 标识符，后面跟一个冒号 ,它放在循环语句的前面。

示例： 在一个二维数组中查找第一个非零元素,找到后立即停止所有搜索。

public class LabeledContinueExample {
    public static void main(String[] args) {
        int[][] matrix = {
            {0, 0, 0, 0},
            {0, 5, 0, 0},
            {0, 0, 0, 0},
            {0, 0, 0, 0}
        };
        boolean found = false;
        // outerLoop 是外层循环的标签
        outerLoop:
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j] != 0) {
                    System.out.println("找到第一个非零元素: matrix[" + i + "][" + j + "] = " + matrix[i][j]);
                    found = true;
                    // 这里的 continue 会跳转到 outerLoop 标记的循环的下一次迭代
                    // 也就是说，它会跳出内层 for 循环，并且外层 for 循环的 i 会自增
                    continue outerLoop;
                }
            }
            System.out.println("第 " + i + " 行未找到非零元素。");
        }
        if (!found) {
            System.out.println("矩阵中所有元素都为零。");
        }
    }
}

执行流程分析：

1. 外层循环 i = 0，内层循环 j 从 0 到 3，所有元素都是 0。
2. 外层循环 i = 1，内层循环 j 从 0 开始。
   • j=0: matrix[1][0] 是 0。
   • j=1: matrix[1][1] 是 5，条件 matrix[i][j] != 0 为真。
   • 打印信息。
   • 执行 continue outerLoop;。
   • 这个 continue 会完全终止当前的内层循环，并且跳转到外层循环 outerLoop 的下一次迭代。
   • 所以内层循环不会继续执行 j=2 和 j=3，外层循环的 i 直接变为 2,开始下一轮。

输出结果：

找到第一个非零元素: matrix[1][1] = 5
第 2 行未找到非零元素。
第 3 行未找到非零元素。

continue vs. break

初学者经常混淆 continue 和 break,这里做一个清晰的对比：

示例对比：

// continue 的例子
System.out.println("--- continue 示例 ---");
for (int i = 0; i < 5; i++) {
    if (i == 2) {
        continue; // 跳过 i=2 的打印
    }
    System.out.println("continue: i = " + i);
}
// 输出: 0, 1, 3, 4
// break 的例子
System.out.println("\n--- break 示例 ---");
for (int i = 0; i < 5; i++) {
    if (i == 2) {
        break; // 当 i=2 时，整个循环终止
    }
    System.out.println("break: i = " + i);
}
// 输出: 0, 1

最佳实践与注意事项

1. 谨慎使用：过度使用 continue 会使代码逻辑变得难以理解和跟踪，尤其是在复杂的嵌套循环中，如果逻辑可以用 if-else 清晰地表达（将 continue 后面的代码都放进 else 块中），那么优先选择 if-else 结构。

   • 可读性差：

     for (int i = 0; i < items.size(); i++) {
         if (items.get(i).isValid()) {
             // ... 大量处理代码 ...
         } else {
             continue; // 跳过
         }
         // ... 更多代码 ...
     }

   • 可读性好：

     for (int i = 0; i < items.size(); i++) {
         if (!items.get(i).isValid()) {
             continue; // 快速跳过无效项
         }
         // ... 只对有效项进行处理 ...
         // ... 更多代码 ...
     }

     这种“卫语句”（Guard Clause）风格，即 if (condition) { return; } 或 if (condition) { continue; }，在早期就处理掉异常或不需要的情况,可以使主逻辑更清晰。

2. 注意 while 循环中的陷阱：如前所述，在 while 或 do-while 循环中，确保 continue 不会导致循环变量未被更新,从而引发死循环。

3. 使用带标签的 continue 要清晰：标签应该有意义的名称，并且只在确实需要跳出多层循环时使用,否则会降低代码的可读性。

• continue 用于跳过当前循环的剩余部分,直接进入下一次循环。
• 在 for 循环中，它会先执行迭代语句（如 i++）,再判断条件。
• 在 while 和 do-while 循环中，它会直接跳转到条件判断，必须小心避免死循环。
• 带标签的 continue 可以从内层循环跳转到外层循环的下一次迭代。
• continue 是“跳过本次”，break 是“跳出循环”。
• 合理使用 continue 可以简化逻辑,但滥用会降低代码质量。