Instruction continue Java

Dans ce tutoriel, vous découvrirez les instructions continue en Java et les instructions marquées continue à l'aide d'exemples.

Lors du traitement des boucles, il peut être nécessaire de sauter certaines instructions de la boucle ou de terminer immédiatement la boucle sans vérifier l'expression de test.

Dans ce cas, les instructions break et continue seront utilisées. Pour comprendre l'instruction break, veuillez consulterJava break。

L'instruction continue en Java saute l'itération actuelle de la boucle (for, while, do…while, etc.), le contrôle du programme est déplacé à la fin de la boucle et l'expression de test de la boucle est calculée.

Pour la boucle for, l'instruction de mise à jour est exécutée avant l'expression de test.

L'instruction continue est presque toujours utilisée dans (Instructions if ... elseIl est utilisé dans les instructions décisionnelles. Sa syntaxe est :

continue;

Comment fonctionne l'instruction continue ?

示例1Instructions continue en Java

class Test {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　//　for boucle
　　　　　　　　for (int i =　1; i <=　10;　++i) {
　　　　　　　　　　　　//Si la valeur de i est comprise entre4和9entre
　　　　　　　　　　　　if (i >　4　&& i <　9) {
　　　　　　　　　　　　　　　　continue;
　　　　　　　　　　　　}　　　　　　
　　　　　　　　　　　　System.out.println(i);
　　　　　　　　}　　　
　　　　}
}

Output:

1
2
3
4
9
10

Dans le programme ci-dessus, nous utilisons une boucle for pour imprimer la valeur de i à chaque itération. Pour comprendre le fonctionnement de la boucle for, veuillez consulterBoucle for Java. Voici quelques points à noter pour les instructions suivantes :

if (i >　5　&& i <　9) {
　　　　continue;
}

Ce qui signifie que lorsque la valeur de i est supérieure à4inférieure9Lorsque cela se produit, l'instruction print de la boucle sera ignorée. Par conséquent, nous sautons la valeur5、6、7和8的输出。

示例2：Java continue语句

下面的程序计算用户输入的5个正数的总和。如果用户输入负数或零，则将其从计算中跳过。

为了接受用户的输入，我们使用了该Scanner对象。要了解更多信息Scanner，请访问Java Scanner。

import java.util.Scanner;
class AssignmentOperator {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　Double number, sum = 0.0;
　　　　　　　　//创建Scanner对象
　　　　　　　　Scanner input = new Scanner(System.in);
　　　　　　
　　　　　　　　for (int i =　1; i <　6;　++i) {
　　　　　　　　　　　　System.out.print("输入一个数字: ");
　　　　　　　　　　　　//接受double类型的数据输入
　　　　　　　　　　　　number = input.nextDouble();
　　　　　　　　　
　　　　　　　　　　　　//如果number为负数，则跳过迭代
　　　　　　　　　　　　if (number <= 0.0) {
　　　　　　　　　　　　　　　　continue;
　　　　　　　　　　　　}
　　　　　　　　　
　　　　　　　　　　　　sum　+= number;
　　　　　　　　}
　　　　　　　　System.out.println("Sum = ",　+　sum);
　　　　}
}

Output:

输入一个数字:　2.2
输入一个数字:　5.6
输入一个数字: 0
输入一个数字:　-2.4
输入一个数字:　-3
Sum =　7.8

在上面的程序中，请注意以下行：

if (number < 0.0) {
　　　　continue;
}

　这意味着当用户输入负数时，将跳过循环的当前迭代。下一个迭代就开始了。

Java continue和嵌套循环

如果是嵌套循环，则continue将跳过最内层循环的当前迭代。

带标签的continue语句

　到目前为止，我们使用了未标记的continue语句。它用于终止最内层的循环和switch语句。然而，Java中还有另一种形式的continue语句，称为标记contine。

如上图所示，我们使用label标识符来指定外部循环。现在，请注意如何使用该continue语句（continue label;）。

　在这里，continue语句将跳过标记语句的当前迭代（即外部循环）。然后，程序的控制转到标记语句的下一次迭代（外循环）

示例3：标记为continue的语句

class LabeledContinue {
　　　　public static void main(String[] args) {
　　　　　　　　//The outer for loop is marked as label　　　　　
　　　　　　　　first:
　　　　　　　　for (int i =　1; i <　6;　++i) {
　　　　　　　　　　　　for (int j =　1; j <　5;　++j) {
　　　　　　　　　　　　　　　　if (i ==　3　|| j ==　2)
　　　　　　　　　　　　　　　　　　　　//Skipping the iteration of the labeled loop (outer for loop)
　　　　　　　　　　　　　　　　　　　　continue first;
　　　　　　　　　　　　　　　　System.out.println("i = ",　+　i　+　"; j = "　+　j);　
　　　　　　　　　　　　}
　　　　　　　　}　
　　　　}
}

Output:

i =　1; j =　1
i =　2; j =　1
i =　4; j =　1
i =　5; j =　1

　In the above example, the current iteration of the loop marked as first is skipped using labeled continue statements.

if (i ==3　|| j ==2)
　　　　continue first;

　Here, we can see that the outermost for loop is marked as first,

first:
for (int i =　1; i <　6;　++i) {..}

　Therefore, if the value of i is3or the value of j is2and skip the iteration of the outer for loop.

NoteIt is usually not recommended to use labeled continue as it makes the code difficult to understand. If you are in a situation where you must use labeled continue, please refactor the code and try to solve it in a different way to make it more readable.