这是一个非常常见且重要的控制流结构,主要用于跳过当前循环的剩余部分，并直接进入下一次循环。

核心概念：if + continue 的工作原理

想象一下你正在逛一个水果摊,你的目标是买苹果，但看到坏苹果时要跳过它。

• 循环：你正在一个接一个地检查水果。
• if 语句：你拿起一个水果，判断它是不是坏的。
• continue：如果你发现这个苹果是坏的，你就说：“跳过这个，看下一个！”，你不会对这个坏苹果做任何处理（比如买它），而是立刻转向下一个水果。

在 Java 代码中，这个逻辑就是：

for (int i = 0; i < 10; i++) {
    // 1. 循环开始，检查条件
    if (i == 5) {
        // 2. i 等于 5，这个条件为 true
        continue; // 3. 执行 continue，立刻跳转到 for 循环的 i++ 部分，然后判断 i < 10 是否成立，以决定是否进入下一次循环
    }
    // 4. if 条件为 false，或者 continue 执行后，代码会从这里继续执行
    System.out.println("当前数字是: " + i);
}

执行流程图：

开始循环
  |
  V
[for 循环条件检查]
  |
  |-- 条件为 false --> 执行循环体代码 --> 循环结束
  |                       |
  |                       V
  |                   [循环体结束]
  |                       |
  |                       V
  |                 [i++ 或 i--]
  |                       |
  |<----------------------|
  |
  |-- 条件为 true --> [if 条件判断]
                      |
                      |-- if 为 false --> 执行循环体代码
                      |                      |
                      |                      V
                      |                  [循环体结束]
                      |                      |
                      |                      V
                      |                  [i++ 或 i--]
                      |                      |
                      |<----------------------|
                      |
                      |-- if 为 true --> 执行 continue
                                           |
                                           V
                                  [跳转到 i++ 或 i--]
                                           |
                                           V
                                  [for 循环条件检查] (回到开始)

代码示例

示例 1：跳过特定数字

这是最经典的例子,打印 1 到 10 的数字，但跳过数字 5。

public class IfContinueExample {
    public static void main(String[] args) {
        System.out.println("开始打印 1 到 10 的数字，但跳过 5:");
        for (int i = 1; i <= 10; i++) {
            // i 是 5，就跳过本次循环的剩余部分
            if (i == 5) {
                continue;
            }
            // 这行代码只有在 i != 5 时才会被执行
            System.out.println("当前数字: " + i);
        }
    }
}

输出结果：

开始打印 1 到 10 的数字，但跳过 5:
当前数字: 1
当前数字: 2
当前数字: 3
当前数字: 4
当前数字: 6
当前数字: 7
当前数字: 8
当前数字: 9
当前数字: 10

可以看到,当 i 变成 5 时，if (i == 5) 为真，continue 被执行，System.out.println(...) 那一行代码被完全跳过，循环直接进入 i++ 并进行下一次判断。

示例 2：处理数组中的偶数

假设我们有一个整数数组,我们只想对奇数进行求和，遇到偶数就跳过。

public class SkipEvenNumbers {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int sum = 0;
        System.out.println("正在对奇数求和...");
        for (int number : numbers) { // 使用 for-each 循环
            // 检查当前数字是否是偶数
            if (number % 2 == 0) {
                System.out.println("发现偶数 " + number + "，跳过。");
                continue; // 如果是偶数，跳过本次循环，继续处理下一个数字
            }
            // 如果执行到这里，说明 number 是奇数
            sum += number;
            System.out.println("累加奇数: " + number + "，当前总和: " + sum);
        }
        System.out.println("所有奇数的最终总和是: " + sum);
    }
}

输出结果：

正在对奇数求和...
累加奇数: 1，当前总和: 1
发现偶数 2，跳过。
累加奇数: 3，当前总和: 4
发现偶数 4，跳过。
累加奇数: 5，当前总和: 9
发现偶数 6，跳过。
累加奇数: 7，当前总和: 16
发现偶数 8，跳过。
累加奇数: 9，当前总和: 25
发现偶数 10，跳过。
所有奇数的最终总和是: 25

continue 在不同类型循环中的使用

continue 不仅可以用于 for 循环，还可以用于 while 和 do-while 循环。

while 循环中的 continue

在 while 循环中，continue 会直接跳转到 while 条件的判断部分。

int j = 0;
while (j < 5) {
    j++; // 必须小心，避免无限循环
    if (j == 3) {
        continue; // 跳过下面的打印语句，直接回到 while (j < 5) 判断
    }
    System.out.println("j 的值是: " + j);
}
// 输出: j 的值是: 1, j 的值是: 2, j 的值是: 4, j 的值是: 5

do-while 循环中的 continue

在 do-while 循环中，continue 会跳转到循环的末尾，先执行 while 条件的判断，再决定是否进入下一次循环。

int k = 0;
do {
    k++;
    if (k == 3) {
        continue; // 跳过下面的打印语句，直接去执行 while (k < 5)
    }
    System.out.println("k 的值是: " + k);
} while (k < 5);
// 输出: k 的值是: 1, k 的值是: 2, k 的值是: 4, k 的值是: 5

continue 与 break 的关键区别

初学者很容易混淆 continue 和 break，它们有本质的不同：

对比示例：

// 使用 continue
System.out.println("--- 使用 continue ---");
for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue; // 跳过 i=3 的情况
    }
    System.out.println("continue: " + i);
}
// 输出: 1, 2, 4, 5
// 使用 break
System.out.println("\n--- 使用 break ---");
for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        break; // 循环在 i=3 时彻底终止
    }
    System.out.println("break: " + i);
}
// 输出: 1, 2

重要注意事项

1. continue 只能在循环内部使用：如果你在循环外面写 if (condition) continue;，编译器会报错。

   int x = 10;
   if (x > 5) {
       // 编译错误: continue outside of loop
       continue;
   }

2. 带标签的 continue (Labeled continue)：当你在嵌套循环中使用 continue 时，默认只会跳过它所在的那一层循环，如果你想跳出外层循环，可以使用带标签的 continue。

   outerLoop: // 为外层循环定义一个标签
   for (int i = 0; i < 3; i++) {
       for (int j = 0; j < 3; j++) {
           if (i == 1 && j == 1) {
               // 这个 continue 会跳转到 outerLoop 标记的位置
               // 即直接结束外层循环的本次迭代 (i++)，并进入下一次外层循环
               continue outerLoop;
           }
           System.out.println("i=" + i + ", j=" + j);
       }
   }
   // 输出:
   // i=0, j=0
   // i=0, j=1
   // i=0, j=2
   // i=2, j=0  <-- 注意 i=1 的整个循环都被跳过了
   // i=2, j=1
   // i=2, j=2

   这里的 continue outerLoop; 的意思是：“停止当前 outerLoop 的这次迭代，直接进入 outerLoop 的下一次迭代”。

if (condition) continue; 是 Java 中一个非常强大的组合，它让你能够根据特定条件优雅地控制循环的执行流程，实现“选择性执行”循环体中的代码，从而写出更清晰、更高效的逻辑，记住它的核心作用是“跳过本次，进入下次”，并时刻与 break 的“彻底终止”相区分。