Unterschied zwischen break und continue-Anweisung

Kann mir jemand den Unterschied zwischen breakund continueAussagen sagen ?

breakhinterlässt eine Schleife und continuespringt zur nächsten Iteration.

Weitere Informationen und Codebeispiele finden Sie unter Verzweigungsanweisungen :

break

Die break-Anweisung hat zwei Formen: beschriftet und unbeschriftet. Sie haben das unbeschriftete Formular in der vorherigen Diskussion der switch-Anweisung gesehen. Sie können auch eine unbeschriftete Unterbrechung verwenden, um eine [...] for-, while- oder do-while-Schleife zu beenden.

Eine unbeschriftete break-Anweisung beendet den innersten Schalter für, while- oder do-while-Anweisung, eine beschriftete break-Anweisung beendet jedoch eine äußere Anweisung.

continue

Die continue-Anweisung überspringt die aktuelle Iteration einer for-, while- oder do-while-Schleife. Das unbeschriftete Formular springt zum Ende des Körpers der innersten Schleife und wertet den booleschen Ausdruck aus, der die Schleife steuert. [...]

Eine beschriftete continue-Anweisung überspringt die aktuelle Iteration einer äußeren Schleife, die mit der angegebenen Beschriftung markiert ist.

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");

Dies führt zu folgender Ausgabe:

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

Sie können einen Block beschriften, nicht nur eine for-Schleife, und dann von einem verschachtelten Block zu einem äußeren Block wechseln / fortfahren. In einigen Fällen kann dies nützlich sein, aber im Allgemeinen versuchen Sie, solchen Code zu vermeiden, außer dass die Logik des Programms viel besser zu verstehen ist als im folgenden Beispiel:

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));
        }
    }       
}

Weil es möglich ist, heißt das nicht, dass Sie es verwenden sollten.

Wenn Sie Ihren Code auf witzige Weise verschleiern möchten, wählen Sie keinen aussagekräftigen Namen, sondern http: und folgen ihm mit einem Kommentar, der fremd aussieht, wie eine Webadresse im Quellcode:

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

Ich denke, das ist von einem Joshua Bloch-Quiz. :) :)

Break verlässt die Schleife vollständig und führt die Anweisungen nach der Schleife aus. Während Continue die aktuelle Iteration verlässt und mit dem nächsten Wert in der Schleife ausgeführt wird.

Dieser Code erklärt alles:

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");
    }
}

Ausgabe:

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

breakverlässt die Schleife vollständig. continueÜberspringt die Anweisungen nach der continue- Anweisung und führt eine Schleife durch.

Break Statement

Manchmal ist es notwendig, eine Schleife zu verlassen bevor die Schleife alle Schrittwerte vollständig durchlaufen hat. Durchlaufen Sie beispielsweise eine Liste von Zahlen, bis Sie eine Zahl finden, die eine bestimmte Bedingung erfüllt. Oder Sie durchlaufen einen Zeichenstrom aus einer Datei, bis ein bestimmtes Zeichen gelesen wird.

Im folgenden Beispiel verwenden wir eine einfache for-Schleife, um Werte von 0 bis 9 auszudrucken:

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

Ausgabe:

0
1
2
3
4
5
6
7
8
9

Wenn wir nun eine break-Anweisung hinzufügen, wenn i == 4 ist, bricht unser Code aus der Schleife aus, sobald i gleich 4 ist. Sie können die break-Anweisung verwenden, um for-Schleifen, while-Schleifen und do-while-Schleifen auszubrechen. Die break-Anweisung bricht nur aus der aktuellen Schleife aus. Um aus einer äußeren Schleife aus einer verschachtelten inneren Schleife auszubrechen, müssten Sie mit der break-Anweisung Beschriftungen verwenden.

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

Ausgabe:

0
1
2
3
4

Erklärung fortsetzen

Die continue-Anweisung von Java überspringt die aktuelle Iteration einer Schleife und geht direkt zur nächsten Iteration über. Nach dem Aufruf der continue-Anweisung in einer for-Schleife führt die Schleifenausführung den Schrittwert aus und wertet die boolesche Bedingung aus, bevor mit der nächsten Iteration fortgefahren wird. Im folgenden Beispiel drucken wir alle Werte von 0 bis 9 in einer Schleife aus, überspringen jedoch das Ausdrucken von 4.

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

Ausgabe:

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

Loop Label - Break Statement Sie können Labels in verschachtelten Loops verwenden indem Sie angeben, wo die Ausführung nach dem Ausbruch aus einer inneren Schleife fortgesetzt werden soll. Normalerweise bricht die break-Anweisung nur aus der innersten Schleife aus. Wenn Sie also aus einer äußeren Schleife ausbrechen möchten, können Sie dazu Beschriftungen verwenden, die im Wesentlichen einer goto-Anweisung ähneln.

Im folgenden Beispiel werden 3 Schleifen verwendet, die alle ineinander verschachtelt sind. Da es keine Möglichkeit gibt, aus der äußersten Schleife innerhalb der innersten Schleife vollständig auszubrechen, können wir die Bezeichnung „Outer1“ verwenden, um dies zu erreichen, und die Bezeichnung neben der break-Anweisung angeben.

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;
      }
    }
  }
}

Ausgabe:

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

Beachten Sie, dass die letzte angezeigte Zeile " 0 [0]" ist, wo j == 3 ist, und dort haben wir "break äußere1" genannt; aus der äußersten Schleife ausbrechen.

Schleifenetiketten - Fortsetzung der Anweisung

Sie können auch Beschriftungen mit dem Schlüsselwort continue verwenden, um die Schleife von einem bestimmten Punkt aus fortzusetzen. Wenn Sie das vorherige Beispiel verwenden und nur eine Zeile ändern, um sie continue outer1;anstelle von anzugeben, break outer1;wird die Schleife weiterhin von der outer1Beschriftung wiederholt, anstatt aus der Schleife auszubrechen. Beachten Sie, wie bei jedem continue outer1;Aufruf der Code von der äußeren Schleife fortgesetzt wird, nachdem der Schleifenindex i um 1 erhöht wurde.

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]

Quelle: Schleifen in Java - Ultimate Guide

Hervorragende Antwort einfach und genau.

Ich würde ein Codebeispiel hinzufügen.

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

Eine breakErklärung resultiert in der Beendigung der Anweisung für die sie gilt ( switch, for, do, oderwhile ).

Eine continueAnweisung wird verwendet, um die aktuelle Schleifeniteration zu beenden und die Steuerung an die Schleifenanweisung zurückzugeben.

continueüberspringt den aktuellen Ausführungsschleife und bewegt sich zu der nächsten Schleife während break auszieht der Schleife und führt die nächste Anweisung nach der Schleife. Ich habe den Unterschied mit dem folgenden Code gelernt. Schauen Sie sich die verschiedenen Ausgaben an. Hoffentlich hilft das.

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

Folgendes berücksichtigen:

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

break beendet die Schleife und der Wert von n ist 0.

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

continue bewirkt, dass der Programmzähler zur ersten Zeile der Schleife zurückkehrt (die Bedingung wird überprüft und der Wert von n wird inkrementiert) und zum Endwert von n ist 10.

Es sollte auch beachtet werden, dass break nur die Ausführung der Schleife beendet, in der es sich befindet:

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);

Gibt etwas zum Effekt von aus

0
0
0
0
0
5

Die breakAnweisung bricht aus der Schleife aus (die nächste auszuführende Anweisung ist die erste nach der schließenden Klammer), während continuedie Schleife bei der nächsten Iteration neu gestartet wird.

Die breakAnweisung enthält die aktuelle Schleifensteuerungsstruktur und springt dahinter, während die continueExits ebenfalls ausgeführt werden, springt jedoch zurück in die Schleifenbedingung.

Einfaches Beispiel:

break verlässt die Schleife.

int m = 0;
for(int n = 0; n < 5; ++n){
  if(n == 2){
    break;
  }
  m++;
}

System.out.printl("m:"+m); // m:2

continue geht zurück, um die Schleife zu starten.

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

Um zu verhindern, dass etwas ausgeführt wird, wenn eine Bedingung erfüllt ist, sollte man die Option continue verwenden und um die Schleife zu verlassen, wenn eine Bedingung erfüllt ist, sollte man die Pause verwenden.

Zum Beispiel im unten genannten Code.

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

        if(i==3){

           continue;

        }
       System.out.println(i);
     }

Der obige Code gibt das Ergebnis aus: 0 1 2 4

Betrachten Sie jetzt diesen Code

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


            if(i==3){

                break;

            }
            System.out.println(i);
         }

Dieser Code gibt 0 1 2 aus

Das ist der grundlegende Unterschied zwischen Fortfahren und Brechen.

Hier ist die Semantik der 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:;

Hier ist die Semantik von weiter:

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:;
}

Erstens denke ich, dass Sie wissen sollten, dass es in Java zwei Arten von Unterbrechungen und Fortsetzungen gibt, die als Unterbrechung, unbeschriftete Unterbrechung, beschriftete Fortsetzung und unbeschriftete Fortsetzung bezeichnet werden. Jetzt werde ich über den Unterschied zwischen ihnen sprechen.

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");
    }
}

Eine unbeschriftete break-Anweisung beendet den innersten Schalter für die while-do-while-Anweisung.

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.
        }
    }
}

Eine beschriftete Unterbrechung beendet eine äußere Anweisung. Wenn Sie diese Demo javac und java verwenden, erhalten Sie:

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.");
}

Eine unbeschriftete continue-Anweisung überspringt die aktuelle Iteration einer for, while, do-while-Anweisung.

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

Eine beschriftete continue-Anweisung überspringt die aktuelle Iteration einer äußeren Schleife, die mit dem angegebenen Etikett markiert ist. Wenn Sie die Demo javac und java verwenden, erhalten Sie:

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

Wenn Sie Fragen haben, können Sie das Java-Tutorial dazu sehen: Geben Sie hier die Linkbeschreibung ein

Einfach ausgedrückt: break beendet die aktuelle Schleife und setzt die Ausführung in der ersten Zeile nach dem Ende der Schleife fort. continue springt zurück zum Loop-Zustand und führt den Loop weiter.

for (int i = 1; i <= 3; i++) {
        if (i == 2) {

            continue;
        }
        System.out.print("[i:" + i + "]");

Versuchen Sie diesen Code in Netbeans. Sie werden den Unterschied zwischen break und continue verstehen

for (int i = 1; i <= 3; i++) {
        if (i == 2) {

            break;
        }
        System.out.print("[i:" + i + "]");

Einfaches Programm, um den Unterschied zwischen Fortfahren und Unterbrechen zu verstehen

Wann continuewird verwendet

    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

Wann breakwird verwendet

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

Statement fortsetzen Stoppen Sie die Itration und starten Sie die nächste Itration. Beispiel:

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 + "]");
    }

und Break Statment stoppen die Schleife oder beenden die Schleife

Sie befinden sich also in einer for- oder while-Schleife. Pause verwenden; bringt Sie außerhalb der Schleife. Wie in wird es enden. Fortsetzen; wird es anweisen, die nächste Iteration auszuführen.

Es macht keinen Sinn, in der if-Anweisung fortzufahren, sondern zu brechen. ist nützlich. Verwenden Sie im Fall switch ... immer break; um einen Fall zu beenden, damit kein anderer Fall ausgeführt wird.