Diferencia entre romper y continuar la declaración

¿Alguien puede decirme la diferencia entre breaky continuedeclaraciones?

breakdeja un bucle, continuesalta a la siguiente iteración.

Vea las declaraciones de ramificación para más detalles y ejemplos de código:

break

La declaración de ruptura tiene dos formas: etiquetada y sin etiqueta. Viste el formulario sin etiquetar en la discusión anterior de la declaración de cambio. También puede usar un salto sin etiqueta para terminar un ciclo for, while o do-while [...]

Una declaración de interrupción sin etiquetar termina el interruptor más interno, para, mientras que, o la declaración de hacer, mientras que una interrupción etiquetada termina una declaración externa.

continue

La instrucción continue omite la iteración actual de un ciclo for, while o do-while. La forma sin etiquetar salta al final del cuerpo del bucle más interno y evalúa la expresión booleana que controla el bucle. [...]

Una declaración de continuación etiquetada omite la iteración actual de un bucle externo marcado con la etiqueta dada.

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

Esto conducirá a la siguiente salida:

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

Puede etiquetar un bloque, no solo un ciclo for, y luego romper / continuar de un bloque anidado a uno externo. En algunos casos, esto puede ser útil, pero en general intentará evitar dicho código, excepto que la lógica del programa es mucho mejor de entender que en el siguiente ejemplo:

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

Porque es posible, no significa que debas usarlo.

Si desea ofuscar su código de una manera divertida, no elija un nombre mezquino, sino http: y sígalo con un comentario, que parece extraño, como una dirección web en el código fuente:

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

Supongo que esto es de un cuestionario de Joshua Bloch. :)

Break deja el ciclo completamente y ejecuta las declaraciones después del ciclo. Mientras que Continuar deja la iteración actual y se ejecuta con el siguiente valor en el bucle.

Este código explica todo:

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

Salida:

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

breaksale completamente del bucle. continuese saltea las declaraciones después de la declaración de continuación y continúa en bucle.

Declaración de ruptura

A veces es necesario salir de un ciclo antes de que el ciclo haya terminado de iterar completamente sobre todos los valores de paso. Por ejemplo, recorrer una lista de números hasta que encuentre un número que satisfaga una determinada condición. O recorrer una secuencia de caracteres de un archivo hasta que se lea un determinado carácter.

En el siguiente ejemplo, estamos usando un bucle for simple para imprimir valores de 0 a 9:

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

Salida:

0
1
2
3
4
5
6
7
8
9

Ahora, si agregamos una declaración de interrupción cuando i == 4, nuestro código saldrá del bucle una vez que sea igual a 4. Puede usar la declaración de interrupción para romper los bucles for, bucles while y bucles do-while. La declaración de ruptura solo saldrá del bucle actual. Para salir de un bucle externo de un bucle interno anidado, necesitaría usar etiquetas con la instrucción break.

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

Salida:

0
1
2
3
4

Continuar declaración

La instrucción continue de Java omite la iteración actual de un bucle y va directamente a la siguiente iteración. Después de llamar a la instrucción continue en un ciclo for, la ejecución del ciclo ejecutará el valor del paso y evaluará la condición booleana antes de continuar con la siguiente iteración. En el siguiente ejemplo, imprimimos todos los valores de 0 a 9 en un bucle, pero omitimos la impresión de 4.

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

Salida:

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

Etiqueta de bucle: declaración de interrupción Puede usar etiquetas dentro de bucles anidados especificando dónde desea que continúe la ejecución después de salir de un bucle interno. Normalmente, la declaración de ruptura solo saldrá del bucle más interno, por lo que cuando desee salir de un bucle externo, puede usar etiquetas para lograr esto, esencialmente haciendo algo similar a una declaración de goto.

El siguiente ejemplo utiliza 3 bucles, todos anidados entre sí. Como no hay forma de salir completamente del bucle más externo desde el interior del bucle más interno, podemos usar la etiqueta "exterior1" para lograr esto y especificar la etiqueta junto a la declaración de interrupción.

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

Salida:

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

Observe cómo la última línea que se muestra es " 0 [0]", que es donde j == 3 y ahí es donde llamamos "break outside1;" para salir del bucle más externo.

Etiquetas de bucle: declaración de continuación

También puede usar etiquetas con la palabra clave continue para continuar haciendo un bucle desde un punto específico. Tomar el ejemplo anterior y simplemente cambiar una línea para especificar en continue outer1;lugar de break outer1;hará que el bucle continúe girando desde la outer1etiqueta en lugar de salir del bucle. Observe cómo continue outer1;se llama cada vez , el código continúa desde el bucle externo después de incrementar el índice del bucle i en 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]

Fuente: Loops en Java - Guía definitiva

Excelente respuesta simple y precisa.

Yo agregaría una muestra de código.

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 breakinforme de resultados en la terminación de la declaración a la que se aplica ( switch, for, do, o while).

Una continuedeclaración se usa para finalizar la iteración del ciclo actual y devolver el control a la declaración del ciclo.

continueomite el ciclo de ejecución actual y se MUEVE al siguiente ciclo, mientras que break SALE del ciclo y ejecuta la siguiente instrucción después del ciclo. Aprendí la diferencia usando el siguiente código. Echa un vistazo a las diferentes salidas. Espero que esto ayude.

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 lo siguiente:

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

break hace que el ciclo termine y el valor de n es 0.

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

continuar hace que el contador del programa regrese a la primera línea del bucle (se verifica la condición y el valor de n es incremental) y el valor final de n es 10.

También debe tenerse en cuenta que break solo termina la ejecución del bucle en el que se encuentra:

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

Producirá algo en el sentido de

0
0
0
0
0
5

La breakinstrucción se rompe del bucle (la siguiente instrucción que se ejecutará es la primera después de la llave de cierre), mientras que continuecomienza el bucle nuevamente en la próxima iteración.

La breakdeclaración existe la estructura de control de bucle actual y salta detrás de ella mientras que la continuesalida también, pero vuelve a la condición de bucle.

Ejemplo simple:

break deja el bucle

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

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

continue volverá al inicio del bucle.

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

Para evitar que algo se ejecute si se cumple una condición, se debe usar continuar y salir del bucle si se cumple una condición, se debe usar el descanso.

Por ejemplo en el código mencionado a continuación.

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

        if(i==3){

           continue;

        }
       System.out.println(i);
     }

El código anterior imprimirá el resultado: 0 1 2 4

Ahora considere este código

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


            if(i==3){

                break;

            }
            System.out.println(i);
         }

Este código imprimirá 0 1 2

Esa es la diferencia básica en la continuación y el descanso.

Aquí está la semántica del descanso:

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

Aquí está la semántica de continuar:

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

Primero, creo que debe saber que hay dos tipos de interrupción y continuar en Java que se denominan interrupción, interrupción sin etiqueta, continúan con etiqueta y continúan sin etiquetar. Ahora, hablaré sobre la diferencia entre ellos.

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

Una declaración de ruptura sin etiquetar termina el interruptor más interno, para, mientras, la declaración de 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.
        }
    }
}

Una ruptura etiquetada termina una declaración externa. Si usted javac y java esta demostración, obtendrá:

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

Una instrucción de continuación sin etiqueta omite la iteración actual de una instrucción 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
        }
    }
}

Una declaración de continuación etiquetada omite la iteración actual de un bucle externo marcado con la etiqueta dada, si javac y java la demostración, obtendrá:

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 tiene alguna pregunta, puede ver el tutorial de Java de esto: ingrese la descripción del enlace aquí

En pocas palabras: break terminará el ciclo actual y continuará la ejecución en la primera línea después de que finalice el ciclo. continuar salta de nuevo a la condición de bucle y sigue ejecutando el bucle.

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

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

pruebe este código en netbeans, comprenderá la diferencia entre romper y continuar

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

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

Programa simple para entender la diferencia entre continuar y romper

Cuando continuese utiliza

    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

Cuando breakse utiliza

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

Continuar Statment detener la iteración y comenzar la siguiente ittration Ej:

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

y Break Statment detienen el bucle o salen del bucle

entonces estás dentro de un ciclo for o while. Usando descanso; te pondrá fuera del circuito. Como en, terminará. Seguir; le dirá que ejecute la próxima iteración.

No tiene sentido usar la instrucción continue in if, pero break; es útil. En el caso de switch ..., use siempre break; para finalizar un caso, para que no ejecute otro caso.