continue 是 Java 中的一个关键字，它被称为跳转语句，它的核心作用是立即终止当前正在执行的循环迭代，并直接跳转到循环的“下一次迭代”。

你可以把它想象成在跑步比赛中,跑完当前一圈后，直接奔向下一圈的起点，而不是在跑完一圈后还要在原地做一些其他事情。

continue 的基本语法和作用

continue 语句非常简单，通常单独成行：

continue;

当程序执行到 continue 时，会发生以下情况：

1. 立即停止：当前循环体中 continue 语句之后的所有代码都将被跳过，不再执行。
2. 进入下一次迭代：程序的控制权会直接传递给循环的条件判断部分（对于 while 和 do-while 循环）或增量/减量部分（对于 for 循环），然后开始下一次循环的执行。

一个简单的例子：

我们打印 1 到 10 的数字，但跳过数字 5。

public class ContinueExample {
    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);
        }
    }
}

输出结果：

当前数字是: 1
当前数字是: 2
当前数字是: 3
当前数字是: 4
当前数字是: 6
当前数字是: 7
当前数字是: 8
当前数字是: 9
当前数字是: 10

可以看到,当 i 变为 5 时，if 条件成立，continue 被执行，System.out.println(...) 被跳过，for 循环直接进入 i++ 和下一次的条件判断。

continue 在不同类型循环中的表现

continue 的行为在不同类型的循环中略有差异，但核心思想一致。

a) 在 for 循环中

在 for 循环中，执行 continue 后，会先执行迭代语句（i++ 部分），然后再进行条件判断。

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

执行流程：

1. i = 0, 打印 i = 0
2. i = 1, 打印 i = 1
3. i = 2, if 成立，执行 continue。
4. 跳过打印，直接执行 i++ (i 变为 3)。
5. 条件判断 3 < 5 成立，继续循环。
6. i = 3, 打印 i = 3
7. ... 以此类推。

b) 在 while 循环中

在 while 循环中，执行 continue 后，会直接跳回到条件判断部分，如果条件仍然为 true，则开始下一次迭代。

注意：如果你不小心，可能会导致无限循环。

int i = 0;
while (i < 5) {
    if (i == 2) {
        continue; // 危险！i 永远不会自增
    }
    System.out.println("i = " + i);
    i++; // 这行在 i == 2 时永远不会执行
}

上面的代码会在 i == 2 时陷入无限循环，正确的写法应该确保 continue 不会阻止循环变量的更新。

int i = 0;
while (i < 5) {
    if (i == 2) {
        i++; // 必须在 continue 之前更新 i
        continue;
    }
    System.out.println("i = " + i);
    i++;
}

c) 在 do-while 循环中

do-while 循环的行为与 while 循环类似，执行 continue 后，会直接跳转到条件判断 while (...) 部分。

带标签的 continue (Labeled `continue)

这是 continue 更高级和强大的用法，当你在嵌套循环（循环中有循环）中使用 continue 时，普通的 continue 只会跳出它所在的那一层循环。

带标签的 continue 可以让你直接跳出指定的外层循环。

语法：

label: // 标签名后面必须跟一个冒号
for (...) {
    for (...) {
        if (...) {
            continue label; // 跳转到标签指定的循环，开始下一次迭代
        }
    }
}

一个经典的例子：

我们想在 3x3 的矩阵中查找一个特定的值，一旦找到，我们就想完全停止搜索，而不是仅仅跳出内层循环。

public class LabeledContinueExample {
    public static void main(String[] args) {
        // 外层循环的标签
        outerLoop:
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                System.out.println("正在检查 i=" + i + ", j=" + j);
                // 假设我们要找的目标是 i=2, j=2
                if (i == 2 && j == 2) {
                    System.out.println("找到目标！停止所有搜索。");
                    // 使用带标签的 continue，跳出 outerLoop 指定的外层循环
                    continue outerLoop;
                }
            }
            // 这里的代码在 i=2 时不会被完全执行完
            System.out.println("外层循环 i=" + i + " 的内层循环已结束。");
        }
        System.out.println("搜索结束。");
    }
}

输出结果：

正在检查 i=1, j=1
正在检查 i=1, j=2
正在检查 i=1, j=3
外层循环 i=1 的内层循环已结束。
正在检查 i=2, j=1
正在检查 i=2, j=2
找到目标！停止所有搜索。
搜索结束。

分析：

1. 当 i=1 时，内层循环完整执行完毕，打印了 "外层循环 i=1 的内层循环已结束。"
2. 当 i=2, j=1 时，正常打印。
3. 当 i=2, j=2 时，if 条件成立，continue outerLoop; 被执行。
4. 这个语句会立即终止整个 outerLoop 的当前迭代，并且由于 i 已经是 2，outerLoop 的条件 i <= 3 仍然为 true，所以它会直接开始 i=3 的迭代。
5. 但是，continue 只是“跳转到下一次迭代”，它并不会完全终止循环，在这个例子中，它会继续执行 i=3 的循环，如果你想要完全终止循环，应该使用 break outerLoop;。

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);
}
// 输出: 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);
}
// 输出: 0, 1

最佳实践和注意事项

1. 避免过度使用：虽然 continue 很方便，但过度使用会使代码逻辑变得难以理解，在某些情况下，可以通过 if-else 结构来避免使用 continue，使代码更线性、更易读。

   使用 continue 的版本：

   for (int i = 0; i < numbers.length; i++) {
       if (numbers[i] <= 0) {
           continue; // 跳过非正数
       }
       // 处理正数...
       System.out.println("处理正数: " + numbers[i]);
   }

   使用 if-else 的版本（可能更清晰）：

   for (int i = 0; i < numbers.length; i++) {
       if (numbers[i] > 0) {
           // 只处理正数
           System.out.println("处理正数: " + numbers[i]);
       }
       // 非正数什么都不做，逻辑更直接
   }

   哪种风格更好取决于个人和团队偏好,但 if-else 的“正面”逻辑有时更容易理解。

2. 注意无限循环：在 while 和 do-while 循环中使用 continue 时，确保循环的终止条件最终能够达成，特别是要小心 continue 是否会阻止循环变量的更新。

3. 标签要清晰：使用带标签的 continue 时，标签名应该具有描述性（如 outerLoop, searchMatrix），以便其他开发者（以及未来的你）能快速理解其意图。

掌握 continue 的用法，特别是带标签的用法，能让你在处理复杂的循环逻辑时更加游刃有余，但请务必谨慎使用，保持代码的清晰和可维护性。