continue 是 Java 循环结构中的一个关键字，它的作用是立即终止当前这一次循环的执行，并直接跳转到循环的条件判断部分,准备进行下一次循环。

continue 会跳过循环体中 continue 语句之后的所有代码,直接进入下一次迭代。

continue 的工作原理

想象一个循环是一个跑道，continue 就像是一个运动员在跑道上，跑到某个点时决定放弃这次跑完，直接回到起点，准备下一圈,他跳过了当前跑道剩余的所有障碍。

• for 循环: 遇到 continue，会立即执行 i++ (或步进表达式),然后执行条件判断。
• while 循环: 遇到 continue,会立即执行条件判断。
• do-while 循环: 遇到 continue,会立即执行条件判断。

continue 在不同循环中的示例

a) for 循环中的 continue

这是最常见的用法，我们来看一个例子：打印 1 到 10 之间除了 5 以外的所有数字。

public class ContinueForLoop {
    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; // 跳转到 for 循环的 i++ 部分
            }
            // 这行代码在 i == 5 时不会执行
            System.out.println("当前数字是: " + i);
        }
    }
}

执行流程分析：

1. i = 1: 条件 i <= 10 为真。if (1 == 5) 为假，打印 "当前数字是: 1"。
2. i = 2: ... 打印 "当前数字是: 2"。
3. i = 3: ... 打印 "当前数字是: 3"。
4. i = 4: ... 打印 "当前数字是: 4"。
5. i = 5: 条件 i <= 10 为真。if (5 == 5) 为真，执行 continue。
   • 跳过 System.out.println(...)。
   • 直接执行 i++，i 变为 6。
6. i = 6: 条件 i <= 10 为真。if (6 == 5) 为假，打印 "当前数字是: 6"。
7. ... 以此类推，直到 i = 10。

输出结果：

打印 1 到 10 之间除了 5 以外的所有数字:
当前数字是: 1
当前数字是: 2
当前数字是: 3
当前数字是: 4
当前数字是: 6
当前数字是: 7
当前数字是: 8
当前数字是: 9
当前数字是: 10

b) while 循环中的 continue

while 循环的 continue 行为类似，但要注意它不会自动更新循环变量，所以必须在 continue 之前处理好变量，或者在 continue 之后、条件判断之前更新它。

public class ContinueWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        System.out.println("使用 while 循环打印 0 到 4:");
        while (i < 5) {
            i++; // 必须在 continue 之前更新，否则如果 i=2 时 continue，i 永远不会增加，导致死循环
            if (i == 3) {
                continue; // 跳转到 while 的条件判断部分 (i < 5)
            }
            System.out.println("当前数字是: " + i);
        }
    }
}

执行流程分析：

1. i = 0, while(0 < 5) 为真。
   • i++ -> i = 1。
   • if(1 == 3) 为假，打印 "当前数字是: 1"。
2. i = 1, while(1 < 5) 为真。
   • i++ -> i = 2。
   • if(2 == 3) 为假，打印 "当前数字是: 2"。
3. i = 2, while(2 < 5) 为真。
   • i++ -> i = 3。
   • if(3 == 3) 为真，执行 continue。
   • 跳过 System.out.println(...)。
   • 直接跳转到 while (i < 5) 判断。
4. i = 3, while(3 < 5) 为真。
   • i++ -> i = 4。
   • if(4 == 3) 为假，打印 "当前数字是: 4"。
5. i = 4, while(4 < 5) 为真。
   • i++ -> i = 5。
   • if(5 == 3) 为假，打印 "当前数字是: 5"。
6. i = 5, while(5 < 5) 为假,循环结束。

输出结果：

使用 while 循环打印 0 到 4:
当前数字是: 1
当前数字是: 2
当前数字是: 4
当前数字是: 5

(注意：这个例子展示了 while 循环中 continue 的一个陷阱，通常将 i++ 放在循环体末尾会更清晰。)

c) do-while 循环中的 continue

do-while 的 continue 逻辑与 while 类似。

public class ContinueDoWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        System.out.println("使用 do-while 循环打印 0 到 4:");
        do {
            i++;
            if (i == 3) {
                continue; // 跳转到 while 的条件判断部分
            }
            System.out.println("当前数字是: " + i);
        } while (i < 5);
    }
}

输出结果与 while 示例相同。

带标签的 continue (Labeled continue)

这是 continue 更高级的用法，当你在嵌套循环中，只想跳出内层循环，继续执行外层循环的当前次迭代时，就需要使用带标签的 continue。

• 语法: continue labelName;
• 规则: labelName 必须是一个合法的 Java 标识符，后面跟一个冒号 ,并且这个标签必须放在你想要跳转到的那个循环语句的前面。

示例：

public class LabeledContinue {
    public static void main(String[] args) {
        // outer 是外层循环的标签
        outer:
        for (int i = 1; i <= 3; i++) {
            System.out.println("外层循环第 " + i + " 次");
            inner:
            for (int j = 1; j <= 3; j++) {
                System.out.println("  内层循环 j = " + j);
                if (j == 2) {
                    System.out.println("    j 等于 2，使用 continue outer 跳出内层循环，继续外层循环的下一次迭代。");
                    continue outer; // 跳出 inner 循环，直接跳转到 outer 循环的下一次迭代 (i++)
                }
                System.out.println("    内层循环继续执行...");
            }
            // 当 j == 2 时，这行代码不会被执行，因为 continue outer 直接跳转到了这里
            System.out.println("  外层循环本次迭代结束。");
        }
        System.out.println("程序结束。");
    }
}

执行流程分析：

1. i = 1:
   • 打印 "外层循环第 1 次"。
   • j 从 1 开始。
     • j = 1: 打印两行，if 条件不满足。
     • j = 2: 打印 "j = 2"。if 条件满足，执行 continue outer。
       • 立即跳出内层 for 循环。
       • 直接跳转到 outer: 标签的位置，准备执行 i++。
   • 打印 "外层循环本次迭代结束。"。
2. i = 2:

   ... (过程同上) ...

3. i = 3:

   ... (过程同上) ...

4. i = 4: 外层循环条件 i <= 3 不满足,循环结束。

输出结果：

外层循环第 1 次
  内层循环 j = 1
    内层循环继续执行...
  内层循环 j = 2
    j 等于 2，使用 continue outer 跳出内层循环，继续外层循环的下一次迭代。
  外层循环本次迭代结束。
外层循环第 2 次
  内层循环 j = 1
    内层循环继续执行...
  内层循环 j = 2
    j 等于 2，使用 continue outer 跳出内层循环，继续外层循环的下一次迭代。
  外层循环本次迭代结束。
外层循环第 3 次
  内层循环 j = 1
    内层循环继续执行...
  内层循环 j = 2
    j 等于 2，使用 continue outer 跳出内层循环，继续外层循环的下一次迭代。
  外层循环本次迭代结束。
程序结束。

continue vs. break

这是一个非常重要的区别,初学者经常混淆。

示例对比：

public class ContinueVsBreak {
    public static void main(String[] args) {
        System.out.println("--- 使用 continue ---");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue; // 跳过 i=3 的这次循环
            }
            System.out.println("continue: " + i);
        }
        System.out.println("\n--- 使用 break ---");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                break; // 遇到 i=3，整个循环终止
            }
            System.out.println("break: " + i);
        }
    }
}

输出结果：

--- 使用 continue ---
continue: 1
continue: 2
continue: 4
continue: 5
--- 使用 break ---
break: 1
break: 2

最佳实践和注意事项

1. 避免过度使用：continue 可以让代码逻辑更清晰（在循环开头处理异常情况），但如果用得太多，会使代码的控制流变得难以跟踪，有时，用 if-else 结构代替 continue 会更直观。

   • 不推荐:

     for (int i = 0; i < list.size(); i++) {
         if (list.get(i) == null) {
             continue;
         }
         // do something with list.get(i)
     }

   • 推荐 (更清晰):

     for (int i = 0; i < list.size(); i++) {
         if (list.get(i) != null) {
             // do something with list.get(i)
         }
     }

2. 注意 while 和 do-while 循环：在这些循环中，continue 不会自动更新循环变量，必须确保循环变量在 continue 之前或之后得到正确更新,否则可能导致死循环。

3. 标签要清晰：使用带标签的 continue 时，标签名应该具有描述性,以便其他开发者能清楚地理解其跳转意图。

continue 是一个强大的循环控制工具，用于跳过特定迭代，在单层循环中，它相当于“本次作废，再来一次”；在嵌套循环中，带标签的 continue 可以让你精确地控制跳转到外层循环的哪个位置，理解它与 break 的区别，并谨慎使用，能帮助你写出更高效、更易读的代码。