continue 是 Java 中的一个关键字，用于立即终止当前正在执行的循环迭代,并直接跳到下一次循环迭代的开始处。

continue 的作用是：跳过本次循环剩余的代码，直接进入下一次循环。

continue 的核心工作原理

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

当程序执行到 continue 语句时：

1. 立即停止：当前循环体中 continue 语句之后的所有代码都将被忽略,不再执行。
2. 跳转：程序的控制权会直接转移到循环的“下一次迭代”的开始点。

这个“开始点”具体是哪里,取决于你使用的是哪种循环：

• for 循环：执行 update（更新）部分，然后判断 condition（条件）。
• while 和 do-while 循环：直接跳转到 condition（条件）判断。

continue 在不同循环中的具体示例

示例 1：在 for 循环中

public class ContinueForLoop {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            // i 是 3 的倍数，就跳过本次循环
            if (i % 3 == 0) {
                System.out.println("发现 " + i + "，跳过打印。");
                continue; // 跳过本次循环的剩余代码，直接执行 i++
            }
            // 这行代码只有在 i 不是 3 的倍数时才会执行
            System.out.println("当前数字是: " + i);
        }
    }
}

输出结果：

当前数字是: 1
当前数字是: 2
发现 3，跳过打印。
当前数字是: 4
当前数字是: 5
发现 6，跳过打印。
当前数字是: 7
当前数字 is: 8
发现 9，跳过打印。
当前数字是: 10

流程分析：

• 当 i 为 1, 2, 4, 5, 7, 8, 10 时，if 条件不成立，continue 不执行，所以会打印出 当前数字是: ...。
• 当 i 为 3 时，if 条件成立，执行 continue，程序会立即跳过 System.out.println("当前数字是: " + i); 这一行，直接执行 for 循环的 i++ 部分，然后判断 i <= 10 是否成立,继续下一次循环。

示例 2：在 while 循环中

public class ContinueWhileLoop {
    public static void main(String[] args) {
        int j = 0;
        while (j < 5) {
            j++; // 必须先递增，否则可能会陷入死循环
            if (j == 3) {
                System.out.println("j 等于 3，跳过本次循环。");
                continue; // 跳转到 while(j < 5) 的判断部分
            }
            System.out.println("j 的值是: " + j);
        }
    }
}

输出结果：

j 的值是: 1
j 的值是: 2
j 等于 3，跳过本次循环。
j 的值是: 4
j 的值是: 5

流程分析：

• j 从 0 开始。
• 第一次循环：j 变为 1，if 不成立，打印 j 的值是: 1。
• 第二次循环：j 变为 2，if 不成立，打印 j 的值是: 2。
• 第三次循环：j 变为 3，if 成立，执行 continue，程序跳过 System.out.println(...)，直接跳回 while (j < 5) 进行判断。
• 第四次循环：j 仍然是 3，j++ 后变为 4，if 不成立，打印 j 的值是: 4。
• 第五次循环：j 变为 5，if 不成立，打印 j 的值是: 5。
• 第六次循环：j 变为 6，while (j < 5) 条件不成立,循环结束。

带标签的 continue (Labeled continue)

这是 continue 更强大的一种用法，当你在嵌套循环中，想从内层循环跳转到外层循环的下一次迭代时，就需要使用带标签的 continue。

语法： label: for (...) { continue label;

这里的 label 是一个自定义的标识符，后面必须跟一个冒号 ,它通常放在外层循环的前面。

示例 3：带标签的 continue

假设我们有一个外层循环遍历星期，一个内层循环遍历一天中的小时，当遇到周三的下午3点时，我们想“跳过”这个小时,继续处理周三的下午4点。

public class LabeledContinue {
    public static void main(String[] args) {
        // 定义一个标签，指向外层循环
        outerLoop:
        for (String day : new String[]{"周一", "周二", "周三", "周四", "周五"}) {
            System.out.println(" --- 开始处理 " + day + " --- ");
            for (int hour = 9; hour <= 17; hour++) {
                // 假设周三下午3点是午休时间，跳过这个小时
                if (day.equals("周三") && hour == 15) {
                    System.out.println(day + " " + hour + ":00 是午休时间，跳过。");
                    continue outerLoop; // 跳转到 outerLoop 标记的循环，即开始处理周四
                }
                System.out.println(day + " " + hour + ":00 正在工作。");
            }
            System.out.println(" --- " + day + " 处理完毕 --- ");
        }
    }
}

输出结果：

 --- 开始处理 周一 ---
周一 9:00 正在工作。
周一 10:00 正在工作。
周一 11:00 正在工作。
周一 12:00 正在工作。
周一 13:00 正在工作。
周一 14:00 正在工作。
周一 15:00 正在工作。
周一 16:00 正在工作。
周一 17:00 正在工作。
 --- 周一 处理完毕 ---
 --- 开始处理 周二 ---
周二 9:00 正在工作。
周二 10:00 正在工作。
... (省略) ...
 --- 周二 处理完毕 ---
 --- 开始处理 周三 ---
周三 9:00 正在工作。
周三 10:00 正在工作。
周三 11:00 正在工作。
周三 12:00 正在工作。
周三 13:00 正在工作。
周三 14:00 正在工作。
周三 15:00 是午休时间，跳过。
 --- 开始处理 周四 ---
周四 9:00 正在工作。
... (省略) ...

流程分析：

• 当程序执行到 continue outerLoop; 时，它不会跳出整个 for 循环，而是会中断当前内层循环，并直接跳转到 outerLoop 标记的外层循环的下一次迭代，周三下午 3 点之后的所有小时（15:00 之后）都被跳过，周三处理完毕”也没有打印,程序直接开始了周四的处理。

continue 与 break 的关键区别

这是一个非常重要的知识点,初学者很容易混淆。

break 示例对比

// 使用 break
for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        break; // 当 i 为 3 时，整个循环直接结束
    }
    System.out.println("break: " + i);
}
// 输出:
// break: 1
// break: 2
// 使用 continue
for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue; // 当 i 为 3 时，跳过本次，继续 i=4
    }
    System.out.println("continue: " + i);
}
// 输出:
// continue: 1
// continue: 2
// continue: 4
// continue: 5

最佳实践与注意事项

1. 避免滥用：虽然 continue 很方便，但过度使用会使代码逻辑变得难以理解和追踪，有时，通过 if-else 结构重构代码会更清晰。

   • 不推荐 (逻辑嵌套深):

     for (int i = 0; i < list.size(); i++) {
         if (list.get(i) != null) {
             if (list.get(i).isValid()) {
                 // ... 主要逻辑
             } else {
                 continue;
             }
         } else {
             continue;
         }
     }

   • 推荐 (逻辑扁平化):

     for (int i = 0; i < list.size(); i++) {
         Item item = list.get(i);
         if (item == null || !item.isValid()) {
             continue; // 先处理所有“不满足条件”的情况
         }
         // ... 这里只写“满足条件”时的主要逻辑，代码更清晰
     }

2. 注意 while 循环中的陷阱：在 while 或 do-while 循环中，continue 执行时，循环变量的更新语句在 if 条件内部，可能会导致死循环。

   • 错误示例 (死循环):

     int k = 0;
     while (k < 5) {
         if (k == 3) {
             System.out.println("k is 3, continue.");
             continue; // k 永远不会自增，k 始终等于 3，循环永远不会结束
         }
         System.out.println("k: " + k);
         k++;
     }

   • 修正方法：确保循环变量的更新（如 i++）在 continue 之前执行，或者放在循环的头部（如 for 循环那样）。

• continue 用于跳过本次循环，进入下一次循环。
• 在 for 循环中，continue 后会执行 update 部分。
• 在 while/do-while 循环中，continue 后会直接进行 condition 判断。
• 带标签的 continue 可以从内层循环跳转到外层循环的下一次迭代,是处理嵌套循环的利器。
• continue 和 break 的核心区别在于一个是“跳过本次”，一个是“终止整个循环”。
• 合理使用 continue 可以简化代码逻辑,但滥用则会降低代码的可读性。