Differenza tra interruzione e istruzione continue

Qualcuno può dirmi la differenza tra breake continuedichiarazioni?

breaklascia un ciclo, continuepassa alla successiva iterazione.

Vedi Dichiarazioni di diramazione per maggiori dettagli ed esempi di codice:

break

L'istruzione break ha due forme: etichettata e senza etichetta. Hai visto la forma senza etichetta nella precedente discussione sull'istruzione switch. Puoi anche usare un'interruzione senza etichetta per terminare un ciclo for, while o do-while [...]

Un'istruzione break senza etichetta termina l'interruttore più interno, per l'istruzione while, o do-while, ma un'interruzione con etichetta termina un'istruzione esterna.

continue

L'istruzione continue salta l'iterazione corrente di un ciclo for, while o do-while. La forma senza etichetta salta alla fine del corpo del ciclo più interno e valuta l'espressione booleana che controlla il ciclo. [...]

Un'istruzione continue con etichetta salta l'attuale iterazione di un ciclo esterno contrassegnato con l'etichetta fornita.

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

Questo porterà al seguente output:

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

È possibile etichettare un blocco, non solo un ciclo continuo, quindi interrompere / continuare da un blocco nidificato a uno esterno. In alcuni casi questo potrebbe essere utile, ma in generale proverai ad evitare tale codice, tranne che la logica del programma è molto meglio da capire rispetto al seguente esempio:

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

Perché è possibile, non significa che dovresti usarlo.

Se vuoi offuscare il tuo codice in modo divertente, non scegli un nome meschino, ma http: e seguilo con un commento, che sembra estraneo, come un indirizzo web nel codice sorgente:

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

Immagino che questo provenga da un quiz di Joshua Bloch. :)

Break lascia il ciclo completamente ed esegue le istruzioni dopo il ciclo. Considerando che Continue lascia l'attuale iterazione ed esegue con il valore successivo nel ciclo.

Questo codice spiega tutto:

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

Produzione:

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

breakesce completamente dal loop. continuesalta le istruzioni dopo l' istruzione continue e continua a girare.

Dichiarazione di rottura

A volte è necessario uscire da un ciclo prima che il ciclo abbia finito di iterare completamente su tutti i valori di passo. Ad esempio, scorrere su un elenco di numeri fino a trovare un numero che soddisfi una determinata condizione. O scorrere su un flusso di caratteri da un file fino a quando non viene letto un determinato carattere.

Nel seguente esempio, stiamo usando un semplice ciclo for per stampare valori da 0 a 9:

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

Produzione:

0
1
2
3
4
5
6
7
8
9

Ora se aggiungiamo un'istruzione break quando i == 4, il nostro codice uscirà dal ciclo quando i sarà uguale a 4. Puoi usare l'istruzione break per uscire per i loop, mentre i loop e i cicli do-while. L'istruzione break uscirà solo dal loop corrente. Per uscire da un loop esterno da un loop interno nidificato, è necessario utilizzare le etichette con l'istruzione break.

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

Produzione:

0
1
2
3
4

Continua Dichiarazione

L' istruzione continue di Java salta sull'iterazione corrente di un ciclo e passa direttamente all'iterazione successiva. Dopo aver chiamato l'istruzione continue in un ciclo for, l'esecuzione del ciclo eseguirà il valore del passo e valuterà la condizione booleana prima di procedere con l'iterazione successiva. Nel seguente esempio, stiamo stampando tutti i valori da 0 a 9 in un ciclo, ma saltiamo la stampa 4.

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

Produzione:

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

Etichetta loop - Dichiarazione di interruzione È possibile utilizzare le etichette all'interno di loop nidificati specificando dove si desidera continuare l'esecuzione dopo l' interruzione di un loop interno. Normalmente, l'istruzione break si romperà solo dal loop più interno, quindi quando si desidera uscire da un loop esterno, è possibile utilizzare le etichette per ottenere ciò, essenzialmente facendo qualcosa di simile a un'istruzione goto.

L'esempio seguente utilizza 3 loop, tutti nidificati l'uno nell'altro. Poiché non è possibile uscire completamente dal loop più esterno dall'interno del loop più interno, è possibile utilizzare l'etichetta "outer1" per ottenere questo risultato e specificare l'etichetta accanto all'istruzione 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;
      }
    }
  }
}

Produzione:

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

Nota come l'ultima riga visualizzata è " 0 [0]" che è dove j == 3 ed è qui che abbiamo chiamato "break outer1;" per uscire dal circuito più esterno.

Etichette a ciclo continuo - Dichiarazione continua

Puoi anche utilizzare le etichette con la parola chiave continue per continuare il ciclo da un punto specifico. Prendendo l'esempio precedente e cambiando solo una riga per specificare continue outer1;invece di break outer1;, il ciclo continuerà a scorrere outer1dall'etichetta invece di interrompersi. Nota come continue outer1;viene chiamato ogni volta , il codice continua dal loop esterno dopo aver incrementato l'indice del loop i di 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]

Fonte: loop in Java - Guida definitiva

Ottima risposta semplice e accurata.

Vorrei aggiungere un esempio di codice.

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

Una breakdichiarazione comporta la cessazione della dichiarazione a cui si applica ( switch, for, do, o while).

continueUn'istruzione viene utilizzata per terminare il ciclo corrente e restituire il controllo l'istruzione ciclica.

continuesalta il loop di esecuzione corrente e SPOSTA al loop successivo mentre si break sposta di OUT dal loop ed esegue l'istruzione successiva dopo il loop. Ho imparato la differenza usando il seguente codice. Dai un'occhiata ai diversi output. Spero che questo aiuti.

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

Considera quanto segue:

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

break fa terminare il loop e il valore di n è 0.

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

continue fa ritornare il contatore del programma alla prima riga del loop (la condizione viene verificata e il valore di n è incrementato) e il valore finale di n è 10.

Va anche notato che break interrompe solo l'esecuzione del loop in cui si trova:

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

Produrrà qualcosa per l'effetto di

0
0
0
0
0
5

L' breakistruzione esce dal ciclo (l'istruzione successiva da eseguire è la prima dopo la parentesi graffa di chiusura), mentre continueinizia il ciclo alla successiva iterazione.

L' breakistruzione esiste l'attuale struttura di controllo del looping e salta dietro di essa mentre anche le continueuscite tornano alla condizione di looping.

Esempio semplice:

break lascia il giro.

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

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

continue tornerà indietro per iniziare il ciclo.

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

Per evitare che qualcosa venga eseguito se viene soddisfatta una condizione, si dovrebbe usare il comando continue e per uscire dal ciclo se si verifica una condizione, si dovrebbe usare l'interruzione.

Ad esempio nel codice sotto indicato.

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

        if(i==3){

           continue;

        }
       System.out.println(i);
     }

Il codice sopra stampa il risultato: 0 1 2 4

NO prendere in considerazione questo codice

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


            if(i==3){

                break;

            }
            System.out.println(i);
         }

Questo codice stamperà 0 1 2

Questa è la differenza fondamentale nel continuare e interrompere.

ecco la semantica della pausa:

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

ecco la semantica di 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:;
}

Innanzitutto, penso che dovresti sapere che ci sono due tipi di interruzioni e continue in Java che sono etichettate break, senza etichetta break, con etichetta continue e senza etichetta continue. Ora, parlerò della differenza tra loro.

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

Un'istruzione break senza etichetta termina l'interruttore più interno, per, mentre, istruzione 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.
        }
    }
}

Un'interruzione etichettata termina un'istruzione esterna. Se javac e java questa demo, otterrai:

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

Un'istruzione continue senza etichetta salta l'attuale iterazione di un'istruzione do, while per 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
        }
    }
}

Un'istruzione continue etichettata salta l'attuale iterazione di un ciclo esterno contrassegnato con l'etichetta indicata, se javac e java la demo otterrai:

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

se hai qualche domanda, puoi vedere il tutorial Java di questo: inserisci qui la descrizione del link

In poche parole: break termina il loop corrente e continua l'esecuzione sulla prima riga dopo la fine del loop. continua torna alla condizione di loop e continua a eseguire il loop.

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

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

prova questo codice in netbeans capirai il diverso tra break e continue

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

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

Programma semplice per capire la differenza tra continue e break

Quando continueviene utilizzato

    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

Quando breakviene utilizzato

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

Continua Statment ferma l'iterazione e inizia la prossima ittrazione 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 + "]");
    }

e Break Statment fermano il loop o Exit dal loop

quindi sei all'interno di un ciclo for o while. Usando la pausa; ti metterà fuori dal giro. Come in, finirà. Continua; dirà di eseguire la prossima iterazione.

Non ha senso utilizzare continue in if statement, ma break; è utile. In switch ... case, usa sempre break; per terminare un caso, quindi non esegue un altro caso.