跳到主要内容

Java Continue语句

在Java编程中，控制流语句是构建程序逻辑的基础。其中，continue语句是循环控制中一个重要的工具，它允许你跳过循环的当前迭代，直接进入下一次迭代。正确理解和使用continue语句可以帮助你编写更简洁、更高效的代码。

continue语句的基本概念​

continue语句用于跳过循环中的某些特定条件下的代码执行，转而直接开始下一次循环迭代。它主要用于以下循环结构中：

  • for循环
  • while循环
  • do-while循环

当Java执行到continue语句时，当前循环迭代中continue后的代码将被跳过，程序流程直接转到循环的下一次迭代。

continue语句的语法​

continue语句的语法非常简单：

java
continue;

或者在嵌套循环中使用带标签的continue：

java
continue label;

continue语句在各种循环中的应用​

在for循环中使用continue​

在for循环中，continue会跳过当前迭代中剩余的代码，然后执行循环的更新部分（例如i++），并继续下一次迭代。

java
public class ContinueInForLoop {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            // 跳过所有偶数
            if (i % 2 == 0) {
                continue;
            }
            System.out.print(i + " ");
        }
    }
}

输出：

1 3 5 7 9

在这个例子中，当i是偶数时，continue语句会跳过循环体中的输出语句，直接进入下一次循环迭代。

在while循环中使用continue​

在while循环中，continue语句会跳过当前迭代中的剩余代码，然后重新检查循环条件。

java
public class ContinueInWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            i++;
            if (i % 3 == 0) {
                continue; // 跳过3的倍数
            }
            System.out.print(i + " ");
        }
    }
}

输出：

1 2 4 5 7 8 10

在这个例子中，当i是3的倍数时，continue语句会跳过输出语句，直接进行下一次循环条件的检查。

在do-while循环中使用continue​

在do-while循环中，continue语句会跳过当前迭代的剩余代码，然后检查循环条件。

java
public class ContinueInDoWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        do {
            i++;
            if (i % 4 == 0) {
                continue; // 跳过4的倍数
            }
            System.out.print(i + " ");
        } while (i < 10);
    }
}

输出：

1 2 3 5 6 7 9 10

带标签的continue语句​

Java还支持带标签的continue语句，这在处理嵌套循环时特别有用。带标签的continue允许你跳到外层循环的下一次迭代。

java
public class LabeledContinue {
    public static void main(String[] args) {
        outerLoop: for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    // 跳过外层循环的当前迭代
                    continue outerLoop;
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
    }
}

输出：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3

在这个例子中，当i=2且j=2时，程序会跳过外层循环的当前迭代（即i=2的整个迭代），直接进入i=3的迭代。

continue vs break​

初学者常常会混淆continue和break语句：

  • continue：跳过当前迭代中剩余的代码，进入下一次循环迭代。
  • break：完全终止整个循环，执行循环后的代码。

下面是一个比较两者区别的例子：

java
public class ContinueVsBreak {
    public static void main(String[] args) {
        System.out.println("使用continue:");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue;
            }
            System.out.print(i + " ");
        }
        
        System.out.println("\n使用break:");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                break;
            }
            System.out.print(i + " ");
        }
    }
}

输出：

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

实际应用案例​

案例1：过滤数据​

continue语句在数据处理和过滤中非常有用。下面的示例展示了如何使用continue来过滤一个整数数组中的负数：

java
public class FilterNegativeNumbers {
    public static void main(String[] args) {
        int[] numbers = {5, -3, 7, 0, -2, 10, -8, 4};
        System.out.println("正数和零：");
        
        for (int num : numbers) {
            if (num < 0) {
                continue; // 跳过负数
            }
            System.out.print(num + " ");
        }
    }
}

输出：

正数和零：
5 7 0 10 4

案例2：跳过特定的处理条件​

在某些业务逻辑中，我们可能需要跳过特定条件的处理。例如，在处理用户输入时，跳过无效输入：

java
import java.util.Scanner;

public class InputValidator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int sum = 0;
        
        System.out.println("请输入10个正整数（负数和零将被忽略）:");
        
        for (int count = 0; count < 10; ) {
            System.out.print("请输入第" + (count + 1) + "个数: ");
            int number = scanner.nextInt();
            
            if (number <= 0) {
                System.out.println("输入无效，必须是正整数！");
                continue;
            }
            
            sum += number;
            count++;
        }
        
        System.out.println("10个正整数的总和是: " + sum);
        scanner.close();
    }
}

在这个例子中，如果用户输入了非正整数，程序会提示用户输入无效，然后跳过当前迭代，不增加count值，也不将输入的数字计入总和。

案例3：在嵌套循环中处理特定模式​

continue语句在打印特定模式时也非常有用，特别是在嵌套循环中：

java
public class PatternPrinting {
    public static void main(String[] args) {
        int rows = 5;
        
        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= rows; j++) {
                // 跳过打印对角线上的星号
                if (i == j) {
                    continue;
                }
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

输出：

* * * * 
* * * * 
* * * * 
* * * * 
* * * *

最佳实践和注意事项​

使用continue语句时，请注意以下几点：

  1. 保持代码清晰：过度使用continue可能会使代码难以理解。确保你的代码逻辑清晰明了。

  2. 避免无限循环：在while和do-while循环中使用continue时，确保循环条件最终会变为false，否则可能导致无限循环。

  3. 更新循环变量：在使用continue之前，确保已经适当地更新了循环计数器或条件变量。

警告

在while和do-while循环中使用continue时，务必确保循环变量在continue之前已经更新，否则可能会导致无限循环。

总结​

continue语句是Java中一个强大的流程控制工具，可以帮助你在循环中跳过特定条件下的代码执行。它在数据处理、输入验证和模式生成等方面有广泛的应用。

通过本教程，你应该已经了解了：

  • continue语句的基本概念和语法
  • 如何在各种循环中使用continue
  • 带标签的continue如何在嵌套循环中工作
  • continue和break语句之间的区别
  • continue语句的实际应用场景

掌握continue语句将帮助你编写更简洁、更高效的Java代码，特别是在处理复杂的循环逻辑时。

练习​

为了加深对continue语句的理解，尝试完成以下练习：

  1. 编写一个程序，打印1到100之间所有不能被3整除的数字。
  2. 创建一个程序，接受用户输入的字符串，并打印出所有非空格字符。
  3. 使用嵌套循环和带标签的continue语句，打印一个5x5的矩阵，但跳过第3行和第3列的所有元素。

进一步阅读​

  • Java语言规范中关于continue语句的部分
  • 其他循环控制语句：break和return
  • 复杂循环结构中的最佳实践