Différence entre break et continue statement

Quelqu'un peut-il me dire la différence entre les déclarations breaket continue?

breaklaisse une boucle, continuepasse à l'itération suivante.

Voir les 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 formulaire sans étiquette dans la discussion précédente sur l'instruction switch. Vous pouvez également utiliser une coupure sans étiquette pour terminer une boucle for, while ou do-while [...]

Une instruction break sans étiquette termine l'interrupteur le plus interne, for, while ou do-while, mais une rupture étiquetée termine une instruction externe.

continue

L'instruction continue ignore l'itération actuelle d'une boucle for, while ou do-while. La forme sans étiquette saute à la fin du corps de la boucle la plus intérieure et évalue l'expression booléenne qui contrôle la boucle. [...]

Une instruction continue étiquetée saute 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 interrompre / continuer d'un bloc imbriqué à un bloc externe. Dans certains cas, cela peut être utile, mais en général, vous essaierez d'éviter un tel 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 devez l'utiliser.

Si vous voulez brouiller votre code d'une manière amusante, vous ne choisissez pas un nom mesquin, mais http: et suivez-le avec un commentaire, qui ressemble à un étranger, comme 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 quizz de Joshua Bloch. :)

Break quitte la boucle complètement 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(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");
    }
}

Production:

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

breakquitte complètement la boucle. continueignore les instructions après l' instruction continue et continue de boucler.

Déclaration de pause

Parfois, il est nécessaire de quitter une boucle avant que la boucle ait fini de parcourir complètement toutes les valeurs de pas. Par exemple, parcourir une liste de nombres jusqu'à ce que vous trouviez un nombre satisfaisant à une certaine condition. Ou en boucle sur un flux de caractères à partir 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);
}

Production:

0
1
2
3
4
5
6
7
8
9

Maintenant, si nous ajoutons une instruction break lorsque i == 4, notre code sortira de la boucle une fois que i est égal à 4. Vous pouvez utiliser l'instruction break pour sortir des boucles for, des boucles while et des boucles do-while. L'instruction break ne sortira que de la boucle actuelle. 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;
  }
}

Production:

0
1
2
3
4

Continuer la déclaration

L' instruction continue de Java ignore 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 passer à l'itération suivante. Dans l'exemple suivant, nous imprimons toutes les valeurs de 0 à 9 en boucle, mais nous ignorons l'impression 4.

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

Production:

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

Libellé de boucle - instruction Break Vous pouvez utiliser des libellés dans des boucles imbriquées en spécifiant où vous souhaitez que l'exécution se poursuive après la rupture d'une boucle interne. Normalement, l'instruction break ne sortira que de la boucle la plus interne, donc lorsque vous voulez sortir d'une boucle externe, vous pouvez utiliser des étiquettes pour accomplir cela, en faisant essentiellement quelque chose de similaire à une instruction goto.

L'exemple suivant utilise 3 boucles, toutes imbriquées les unes dans les autres. Puisqu'il n'y a aucun moyen de sortir complètement de la boucle la plus externe de l'intérieur de la boucle la plus interne, nous pouvons utiliser l'étiquette «external1» 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;
      }
    }
  }
}

Production:

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

Remarquez comment la dernière ligne affichée est " 0 [0]", où j == 3 et c'est là que nous avons appelé "break external1;" pour sortir de la boucle la plus externe.

Étiquettes de boucle - Instruction Continue

Vous pouvez également utiliser des étiquettes avec le mot-clé continue pour continuer la boucle à 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;, la boucle continuera à boucler à partir de l' outer1étiquette au lieu de sortir de la boucle. Notez comment chaque fois que vous continue outer1;êtes appelé, le code continue à partir de la boucle externe après incrémentation de l'index 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

Excellente réponse simple et précise.

J'ajouterais 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

Un breakrésultat de déclaration à la fin de la déclaration à laquelle elle applique ( switch, for, doou while).

Une continueinstruction est utilisée pour terminer l'itération de boucle en cours et retourner le contrôle à l'instruction de boucle.

continuesaute la boucle en cours d'exécution et se déplace vers la boucle suivante tandis que break MOVES OUT 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. 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 sur 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 break ne met fin qu'à 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);

Sortira quelque chose à l'effet de

0
0
0
0
0
5

L' breakinstruction sort de la boucle (la prochaine instruction à exécuter est la première après l'accolade fermante), tandis que continuela boucle recommence à la prochaine itération.

L' breakinstruction existe la structure de contrôle de boucle actuelle et saute derrière elle tandis que les continuesorties aussi mais sautant en arrière à la condition de boucle.

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 pour 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

Pour empêcher l'exécution de quoi que ce soit si une condition est remplie, il faut utiliser la continuation 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érer ce code

 for(int i=0;i<5;i++){


            if(i==3){

                break;

            }
            System.out.println(i);
         }

Ce code sera imprimé 0 1 2

C'est la différence fondamentale dans la poursuite 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:;
}

Tout d'abord, je pense que vous devez savoir qu'il existe deux types de pause et de continuer en Java qui sont étiquetés break, break sans étiquette, continue continue et sans étiquette continue. Maintenant, je vais parler de la différence entre eux.

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 sans étiquette met fin à l'interrupteur le plus interne, pour, pendant, l'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 coupure étiquetée termine une instruction externe. Si vous javacs et java 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 actuelle 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 continue étiquetée saute l'itération actuelle d'une boucle externe marquée avec le libellé donné, si vous javacs 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

Autrement dit: break mettra fin à la boucle actuelle et poursuivra l'exécution à la première ligne après la fin de la boucle. continue revient à l'état de 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 interrompre

Quand continueest 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 breakest 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

Poursuivre l'instruction arrêter l'itération et démarrer la prochaine itération 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 quitter la boucle

vous êtes donc dans une boucle for ou while. Utilisation de pause; vous mettra en dehors de la boucle. Comme dans, cela prendra fin. Continuer; lui dira d'exécuter la prochaine itération.

Inutile d'utiliser l'instruction continue in if, mais break; est utile. Dans le cas du commutateur ..., utilisez toujours break; pour terminer un cas, il n'exécute donc pas d'autre cas.