Différence entre la pause et la déclaration continue

break laisse une boucle, continue sauter à la prochaine itération.

Voir les instructions de twigment pour plus de détails et des exemples de code:

break

La déclaration de rupture a deux formes: étiquetée et non étiquetée. Vous avez vu le formulaire sans étiquette dans la discussion précédente de l’instruction switch. Vous pouvez également utiliser une pause sans étiquette pour terminer une boucle for, while ou do-while […]

Une instruction break non étiquetée met fin à l’instruction switch, for, while ou do-while la plus interne, mais une rupture étiquetée termine une instruction externe.

continue

L’instruction continue ignore l’itération en cours d’une boucle for, while ou do-while. Le formulaire sans étiquette passe à la fin du corps de la boucle la plus interne et évalue l’expression booléenne qui contrôle la boucle. […]

Une instruction continue étiquetée ignore l’itération en cours d’une boucle externe marquée avec l’étiquette donnée.

 System.out.println ("starting loop:"); for (int n = 0; n < 7; ++n) { System.out.println ("in loop: " + n); if (n == 2) { continue; } System.out.println (" survived first guard"); if (n == 4) { break; } System.out.println (" survived second guard"); // continue at head of loop } // break out of loop System.out.println ("end of loop or exit via break"); 

Cela conduira à la sortie suivante:

 starting loop: in loop: 0 survived first guard survived second guard in loop: 1 survived first guard survived second guard in loop: 2 in loop: 3 survived first guard survived second guard in loop: 4 survived first guard end of loop or exit via break 

Vous pouvez étiqueter un bloc, pas seulement un for-loop, puis casser / continuer d'un bloc nested à un autre. Dans certains cas, cela peut être utile, mais en général, vous essayerez d'éviter ce code, sauf que la logique du programme est beaucoup mieux comprise que dans l'exemple suivant:

 first: for (int i = 0; i < 4; ++i) { second: for (int j = 0; j < 4; ++j) { third: for (int k = 0; k < 4; ++k) { System.out.println ("inner start: i+j+k " + (i + j + k)); if (i + j + k == 5) continue third; if (i + j + k == 7) continue second; if (i + j + k == 8) break second; if (i + j + k == 9) break first; System.out.println ("inner stop: i+j+k " + (i + j + k)); } } } 

Parce que c'est possible, cela ne signifie pas que vous devriez l'utiliser.

Si vous voulez brouiller votre code de façon amusante, vous ne choisissez pas un nom méchant, mais http: et suivez-le avec un commentaire, qui a l'air étranger, comme une webadresse dans le code source:

 http://stackoverflow.com/questions/462373 for (int i = 0; i < 4; ++i) { if (i == 2) break http; 

Je suppose que cela vient d'un jeu de Joshua Bloch. 🙂

Break quitte complètement la boucle et exécute les instructions après la boucle. Alors que Continue quitte l’itération en cours et s’exécute avec la valeur suivante dans la boucle.

Ce code explique tout:

 public static void main(Ssortingng[] args) { for(int i=0;i<10;i++) { if (i==4) { break; } System.out.print(i+"\t"); } System.out.println(); for(int i=0;i<10;i++) { if (i==4) { continue; } System.out.print(i+"\t"); } } 

Sortie:

 0 1 2 3 0 1 2 3 5 6 7 8 9 

break complètement quitte la boucle. continue ignore les instructions après l’instruction continue et continue à boucler.

Excellente réponse simple et précise.

Je voudrais append un échantillon de code.

 C:\oreyes\samples\java\breakcontinue>type BreakContinue.java class BreakContinue { public static void main( Ssortingng [] args ) { for( int i = 0 ; i < 10 ; i++ ) { if( i % 2 == 0) { // if pair, will jump continue; // don't go to "System.out.print" below. } System.out.println("The number is " + i ); if( i == 7 ) { break; // will end the execution, 8,9 wont be processed } } } } C:\oreyes\samples\java\breakcontinue>java BreakContinue The number is 1 The number is 3 The number is 5 The number is 7 

Une instruction break entraîne la fin de l’instruction à laquelle elle s’applique ( switch , for , do ou while ).

Une instruction continue est utilisée pour mettre fin à l’itération de la boucle en cours et renvoyer le contrôle à l’instruction loop.

continue ignore la boucle en cours d’exécution et se déplace sur la boucle suivante tandis que la break SE DÉPLACE DE la boucle et exécute l’instruction suivante après la boucle. J’ai appris la différence en utilisant le code suivant. Découvrez les différentes sorties. Espérons que cela aide.

 public static void main(Ssortingng[] args) { for(int i = 0; i < 5; i++){ if (i == 3) { continue; } System.out.print(i); } }//prints out 0124, continue moves to the next iteration skipping printing 3 public static void main(String[] args) { for(int i = 0; i < 5; i++){ if (i == 3) { break; } System.out.print(i); } }//prints out 012, break moves out of the loop hence doesnt print 3 and 4 

Considérer ce qui suit:

 int n; for(n = 0; n < 10; ++n) { break; } System.out.println(n); 

break provoque la fin de la boucle et la valeur de n est 0.

 int n; for(n = 0; n < 10; ++n) { continue; } System.out.println(n); 

continue provoque le retour du compteur de programme à la première ligne de la boucle (la condition est vérifiée et la valeur de n est incrémentée) et la valeur finale de n est 10.

Il convient également de noter que la rupture ne termine que l'exécution de la boucle dans laquelle elle se trouve:

 int m; for(m = 0; m < 5; ++m) { int n; for(n = 0; n < 5; ++n) { break; } System.out.println(n); } System.out.println(m); 

Produira quelque chose à l'effet de

 0 0 0 0 0 5 

L’instruction break se sépare de la boucle (la prochaine instruction à exécuter est la première après l’accolade de fermeture), tandis que continue démarre la boucle à l’itération suivante.

Déclaration de rupture

Il est parfois nécessaire de quitter une boucle avant que la boucle ne soit complètement itérée sur toutes les valeurs de pas. Par exemple, faites une boucle sur une liste de nombres jusqu’à ce que vous trouviez un nombre satisfaisant une certaine condition. Ou en boucle sur un stream de caractères d’un fichier jusqu’à ce qu’un certain caractère soit lu.

Dans l’exemple suivant, nous utilisons une simple boucle for pour imprimer des valeurs de 0 à 9:

 for(int i=0; i<10; i++) { System.out.println(i); } 

Sortie:

 0 1 2 3 4 5 6 7 8 9 

Maintenant, si nous ajoutons une instruction de rupture lorsque i == 4, notre code sortira de la boucle une fois que 4 sera égal à 4. Vous pouvez utiliser l'instruction break pour sortir des boucles, des boucles et des boucles do-while. L'instruction break ne sortira que de la boucle en cours. Pour sortir d'une boucle externe d'une boucle interne nestede, vous devez utiliser des étiquettes avec l'instruction break.

 for(int i=0; i<10; i++) { System.out.println(i); if(i==4) { break; } } 

Sortie:

 0 1 2 3 4 

Continuer déclaration

L' instruction continue de Java ignore l'itération en cours d'une boucle et passe directement à l'itération suivante. Après avoir appelé l'instruction continue dans une boucle for, l'exécution de la boucle exécutera la valeur de l'étape et évaluera la condition booléenne avant de poursuivre l'itération suivante. Dans l'exemple suivant, nous imprimons toutes les valeurs de 0 à 9 dans une boucle, mais nous ignorons l'impression 4.

 for(int i=0; i<10; i++) { if(i==4) { continue; } System.out.println(i); } 

Sortie:

 0 1 2 3 5 <---- SKIPPED OVER 4 and continued with next loop iteration 6 7 8 9 

Libellé de boucle - Instruction de rupture Vous pouvez utiliser des étiquettes dans les boucles nestedes en spécifiant où vous souhaitez que l'exécution se poursuive après avoir quitté une boucle interne. Normalement, l'instruction break ne sortira que de la boucle la plus interne. Lorsque vous souhaitez sortir d'une boucle externe, vous pouvez utiliser des libellés pour accomplir cette tâche, en faisant essentiellement quelque chose de similaire à une instruction goto.

L'exemple suivant utilise 3 boucles, toutes nestedes les unes dans les autres. Comme il n'y a aucun moyen de sortir complètement de la boucle la plus interne à l'intérieur de la boucle la plus interne, nous pouvons utiliser le libellé «outer1» pour y parvenir et spécifier l'étiquette à côté de l'instruction break.

 outer1: for(int i=0; i<5; i++) { for(int j=0; j<4; j++) { for(int k=0; k<2; k++) { System.out.println("[" + i + "][" + j + "][" + k + "]"); if(j == 3) { break outer1; } } } } 

Sortie:

 [0][0][0] [0][0][1] [0][1][0] [0][1][1] [0][2][0] [0][2][1] [0][3][0] 

Remarquez que la dernière ligne affichée est “ 0 [0]” qui est où j == 3 et c'est là que nous appelons “break outer1;” pour sortir de la boucle la plus externe.

Étiquettes de boucle - Déclaration continue

Vous pouvez également utiliser des libellés avec le mot-clé continue pour continuer à boucler à partir d'un point spécifique. En prenant l'exemple précédent et en changeant simplement une ligne pour spécifier, continue outer1; au lieu de break outer1; provoquera la boucle à continuer à boucler à partir de l'étiquette outer1 au lieu de sortir de la boucle. Notez comment chaque fois continue outer1; est appelée, le code continue de la boucle externe après incrémentation de l’indice de boucle i de 1.

 outer1: for(int i=0; i<5; i++) { for(int j=0; j<4; j++) { for(int k=0; k<2; k++) { System.out.println("[" + i + "][" + j + "][" + k + "]"); if(j == 3) { continue outer1; } } } [0][0][0] [0][0][1] [0][1][0] [0][1][1] [0][2][0] [0][2][1] [0][3][0] <---- CONTINUE WITH LABEL CALLED HERE [1][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP [1][0][1] [1][1][0] [1][1][1] [1][2][0] [1][2][1] [1][3][0] <---- CONTINUE WITH LABEL CALLED HERE [2][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP [2][0][1] [2][1][0] [2][1][1] [2][2][0] [2][2][1] [2][3][0] <---- CONTINUE WITH LABEL CALLED HERE [3][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP [3][0][1] [3][1][0] [3][1][1] [3][2][0] [3][2][1] [3][3][0] <---- CONTINUE WITH LABEL CALLED HERE [4][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP [4][0][1] [4][1][0] [4][1][1] [4][2][0] [4][2][1] [4][3][0] 

Source: Loops in Java - Guide ultime

L’énoncé de break existe la structure de contrôle de bouclage actuelle et saute derrière pendant que le continue termine aussi, mais retourne à la condition de bouclage.

Pour empêcher que quelque chose soit exécuté si une condition est remplie, il faut utiliser le continue et pour sortir de la boucle si une condition est remplie, il faut utiliser le break.

Par exemple dans le code mentionné ci-dessous.

  for(int i=0;i<5;i++){ if(i==3){ continue; } System.out.println(i); } 

Le code ci-dessus imprimera le résultat: 0 1 2 4

NOw considérez ce code

  for(int i=0;i<5;i++){ if(i==3){ break; } System.out.println(i); } 

Ce code imprimera 0 1 2

C'est la différence fondamentale dans le continu et la pause.

voici la sémantique de la rupture:

 int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 }; // find 9 for(int i = 0; i < a.Length; i++) { if (a[i] == 9) goto goBreak; Console.WriteLine(a[i].ToString()); } goBreak:; 

voici la sémantique de continuer:

 int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 }; // skip all odds for(int i = 0; i < a.Length; i++) { if (a[i] % 2 == 1) goto goContinue; Console.WriteLine(a[i].ToString()); goContinue:; } 

Premièrement, je pense que vous devriez savoir qu’il ya deux types de pause dans Java qui sont étiquetés pause, pause non étiquetée, étiquetés continuer et non étiquetés continue.Maintenant, je vais parler de la différence entre eux.

 class BreakDemo { public static void main(Ssortingng[] args) { int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 }; int searchfor = 12; int i; boolean foundIt = false; for (i = 0; i < arrayOfInts.length; i++) { if (arrayOfInts[i] == searchfor) { foundIt = true; break;//this is an unlabeled break,an unlabeled break statement terminates the innermost switch,for,while,do-while statement. } } if (foundIt) { System.out.println("Found " + searchfor + " at index " + i); } else { System.out.println(searchfor + " not in the array"); } } 

Une instruction break non étiquetée termine le commutateur le plus à l’intérieur, pour, tandis que, de l’instruction do-while.

 public class BreakWithLabelDemo { public static void main(Ssortingng[] args) { search: for (int i = 0; i < 3; i++) { for (int j = 0; j < 5; j++) { System.out.println(i + " - " + j); if (j == 3) break search;//this is an labeled break.To notice the lab which is search. } } } 

Une pause étiquetée termine une instruction externe. Si vous lancez javac et java cette démo, vous obtiendrez:

 0 - 0 0 - 1 0 - 2 0 - 3 

 class ContinueDemo { public static void main(Ssortingng[] args) { Ssortingng searchMe = "peter piper picked a " + "peck of pickled peppers"; int max = searchMe.length(); int numPs = 0; for (int i = 0; i < max; i++) { // interested only in p's if (searchMe.charAt(i) != 'p') continue;//this is an unlabeled continue. // process p's numPs++; } System.out.println("Found " + numPs + " p's in the string."); } 

Une instruction continue non étiquetée ignore l'itération en cours d'une instruction for, while et do-while.

 public class ContinueWithLabelDemo { public static void main(Ssortingng[] args) { search: for (int i = 0; i < 3; i++) { for (int j = 0; j < 5; j++) { System.out.println(i + " - " + j); if (j == 3) continue search;//this is an labeled continue.Notice the lab which is search } } } 

Une déclaration continue étiquetée ignore l'itération en cours d'une boucle externe marquée avec le repère donné, si vous javac et java la démo, vous obtiendrez:

 0 - 0 0 - 1 0 - 2 0 - 3 1 - 0 1 - 1 1 - 2 1 - 3 2 - 0 2 - 1 2 - 2 2 - 3 

si vous avez des questions, vous pouvez voir le tutoriel Java de ceci: entrez la description du lien ici

Exemple simple:

break quitte la boucle.

 int m = 0; for(int n = 0; n < 5; ++n){ if(n == 2){ break; } m++; } System.out.printl("m:"+m); // m:2 

continue va revenir à démarrer la boucle.

 int m = 0; for(int n = 0; n < 5; ++n){ if(n == 2){ continue; // Go back to start and dont execute m++ } m++; } System.out.printl("m:"+m); // m:4 

Simplement mis: break mettra fin à la boucle en cours et continuera l’exécution à la première ligne après la fin de la boucle. continue à revenir à la condition de la boucle et continue à exécuter la boucle.

 for (int i = 1; i <= 3; i++) { if (i == 2) { continue; } System.out.print("[i:" + i + "]"); 

essayez ce code dans netbeans vous comprendrez la différence entre pause et continuer

 for (int i = 1; i <= 3; i++) { if (i == 2) { break; } System.out.print("[i:" + i + "]"); 

Programme simple pour comprendre la différence entre continuer et casser

Quand continue est utilisé

  public static void main(Ssortingng[] args) { System.out.println("HelloWorld"); for (int i = 0; i < 5; i++){ System.out.println("Start For loop i = " + i); if(i==2){ System.out.println("Inside if Statement for i = "+i); continue; } System.out.println("End For loop i = " + i); } System.out.println("Completely out of For loop"); } OutPut: HelloWorld Start For loop i = 0 End For loop i = 0 Start For loop i = 1 End For loop i = 1 Start For loop i = 2 Inside if Statement for i = 2 Start For loop i = 3 End For loop i = 3 Start For loop i = 4 End For loop i = 4 Completely out of For loop 

Quand la break est utilisée

 public static void main(Ssortingng[] args) { System.out.println("HelloWorld"); for (int i = 0; i < 5; i++){ System.out.println("Start For loop i = " + i); if(i==2){ System.out.println("Inside if Statement for i = "+i); break; } System.out.println("End For loop i = " + i); } System.out.println("Completely out of For loop"); } Output: HelloWorld Start For loop i = 0 End For loop i = 0 Start For loop i = 1 End For loop i = 1 Start For loop i = 2 Inside if Statement for i = 2 Completely out of For loop 

Continue Statment arrête l’itération et commence la prochaine itération

 System.out.println("continue when i is 2:"); for (int i = 1; i <= 3; i++) { if (i == 2) { System.out.print("[continue]"); continue; } System.out.print("[i:" + i + "]"); } 

et Break Statment arrête la boucle ou quitte la boucle

vous êtes donc dans une boucle for ou while. En utilisant la pause; va vous mettre en dehors de la boucle. Comme dans, ça va finir. Continuer; lui dira d’exécuter la prochaine itération.

Aucun point en utilisant continue dans si déclaration, mais casser; est utile. Dans switch … cas, utilisez toujours break; pour mettre fin à un cas, il n’exécute pas un autre cas.