Différence entre les instructions break et continue
Quelqu'un peut-il me dire la différence entre les déclarations break et continue?
break laisse une boucle, continue saute à la prochaine itération.
Voir Instructions de branchement pour plus de détails et des exemples de code:
break
L'instruction break a deux formes: étiquetée et non étiquetée. Vous avez vu le forme sans étiquette dans la discussion précédente de l'instruction switch. Vous peut également utiliser une pause non étiquetée pour terminer un for, while ou do-while boucle [...]
Une instruction break sans étiquette termine le commutateur le plus profond, pour, Une instruction while ou do-while, mais une pause étiquetée termine un .__ extérieur. déclaration.
continue
L'instruction continue ignore l'itération en cours de a, tant que, ou boucle tout-en-un. La forme sans étiquette passe à la fin de la plus profonde le corps de la boucle et évalue l'expression booléenne qui contrôle le boucle. [...]
Une instruction étiquetée continue ignore l'itération actuelle 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 une boucle for, puis casser/continuer d'un bloc imbriqué à un autre. Dans quelques 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 à comprendre 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 obscurcir votre code de façon amusante, vous ne choisissez pas un nom méchant, mais http: et vous le suivez avec un commentaire qui ressemble étrangement à une adresse Web 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 caszzle de Joshua Bloch. :)
Break quitte complètement la boucle et exécute les instructions après la boucle. Attendu que Continue quitte l'itération actuelle et s'exécute avec la valeur suivante de la boucle.
Ce code explique tout:
public static void main(String[] 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 quitte complètement la boucle. continue ignore les instructions après l'instruction continue et continue à boucler.
Excellente réponse simple et précise.
Je voudrais ajouter un exemple de code.
C:\oreyes\samples\Java\breakcontinue>type BreakContinue.Java
class BreakContinue {
public static void main( String [] 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 de la boucle.
Déclaration de pause
Parfois, il est nécessaire de sortir d’une boucle avant que la boucle n’ait fini de parcourir complètement toutes les valeurs de pas. Par exemple, parcourez une liste de nombres jusqu'à ce que vous trouviez un nombre satisfaisant une certaine condition. Ou boucle sur un flux 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 les 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 break quand i == 4, notre code se séparera de la boucle une fois que i sera égal à 4. Vous pouvez utiliser l'instruction break pour rompre les boucles for, while et do-while. L'instruction break ne fera que sortir de la boucle en cours. Pour sortir d'une boucle externe d'une boucle interne imbriquée, 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
Déclaration Continue
L'instruction continue de Java saute l'itération actuelle 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 procéder à la prochaine itération. Dans l'exemple suivant, nous imprimons en boucle toutes les valeurs comprises entre 0 et 9, 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
Loop Label - Instruction Break Vous pouvez utiliser labels dans les boucles imbriquées en spécifiant l'endroit où vous souhaitez que l'exécution se poursuive après la sortie d'une boucle interne. Normalement, l’instruction break ne sortira que de la boucle la plus interne. Ainsi, lorsque vous souhaitez vous échapper d’une boucle externe, vous pouvez utiliser des étiquettes pour accomplir cela.
L'exemple suivant utilise 3 boucles, toutes imbriquées les unes dans les autres. Comme il n’ya aucun moyen de sortir complètement de la boucle la plus externe de la plus interne, nous pouvons utiliser l’étiquette «outer1» pour accomplir cela 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]
Notez que la dernière ligne affichée est “ 0 [0]”, où j == 3 et que nous avons appelé “break outer1;” pour sortir de la boucle la plus externe.
Etiquettes de boucle - Déclaration de continuation
Vous pouvez également utiliser des étiquettes avec le mot clé continue pour continuer à boucler à partir d'un point spécifique. En prenant l'exemple précédent et en changeant juste une ligne pour spécifier continue outer1; au lieu de break outer1;, la boucle continuera à boucler à partir de l'étiquette outer1 au lieu de sortir de la boucle. Notez que chaque fois que continue outer1; est appelé, le code continue à partir de la boucle externe après avoir incrémenté 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: Boucles en Java - Ultimate Guide
continue saute l'exécution en cours loop et MOVES TO le prochain loop alors que breakMOVES OUT du loop et exécute l'instruction suivante après loop . J'ai appris la différence en utilisant le code suivant. Découvrez les différentes sorties. J'espère que cela vous aidera.
public static void main(String[] 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 fait revenir le compteur de programme à la première ligne de la boucle (la condition est vérifiée et la valeur de n incrémentée) et la valeur finale de n est 10.
Il convient également de noter que break termine uniquement l’exécution de la boucle dans laquelle il 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 sort de la boucle (l'instruction suivante à exécuter est la première après l'accolade fermante), tandis que continue lance la boucle à la prochaine itération.
L'instruction break existe avec la structure de contrôle de boucle en cours et saute derrière elle tandis que la variable continue quitte également, mais revient à la condition de boucle.
Pour empêcher quoi que ce soit d’exécuter si une condition est remplie, il convient d’utiliser les commandes continue et pour sortir de la boucle si une condition est remplie, il convient d’utiliser la pause.
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ère ce code
for(int i=0;i<5;i++){
if(i==3){
break;
}
System.out.println(i);
}
Ce code imprimera 0 1 2
Telle est la différence fondamentale entre la poursuite et la pause.
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 retournera à la boucle de départ.
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
Premièrement, je pense que vous devriez savoir qu'il existe deux types de pause et continuer en Java qui sont étiquetés pause, pause sans étiquette, étiquetée continue et continue sans étiquette.
class BreakDemo {
public static void main(String[] 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 intérieur, pour une instruction do-while.
public class BreakWithLabelDemo {
public static void main(String[] 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 déclaration externe. Si vous utilisez Java et cette démo, vous obtiendrez:
0 - 0
0 - 1
0 - 2
0 - 3
class ContinueDemo {
public static void main(String[] args) {
String 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 sans étiquette ignore l'itération en cours d'une instruction for, while, do-while.
public class ContinueWithLabelDemo {
public static void main(String[] 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 instruction étiquetée continue ignore l'itération en cours d'une boucle externe marquée avec le libellé donné. Si vous utilisez 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
voici la sémantique de pause:
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 continue:
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:;
}
Programme simple pour comprendre la différence entre continuer et pause
Quand continue est utilisé
public static void main(String[] 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 break est utilisé
public static void main(String[] 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
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 break et continue
for (int i = 1; i <= 3; i++) {
if (i == 2) {
break;
}
System.out.print("[i:" + i + "]");
En termes simples: break met fin à la boucle en cours et poursuit l'exécution à la première ligne suivant la fin de la boucle continue revient à la condition de boucle et continue à exécuter la boucle.
Continue Statment arrête l'itération et démarre l'itération suivante .___. Ex:
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êter la boucle ou sortir de la boucle