Diferença entre a instrução break e continue

Alguém pode me dizer a diferença entre breake continuedeclarações?

breaksai de um loop, continuepula para a próxima iteração.

Consulte Instruções de ramificação para obter mais detalhes e exemplos de código:

break

A declaração de quebra tem duas formas: rotulada e não rotulada. Você viu o formulário não rotulado na discussão anterior da instrução switch. Você também pode usar uma pausa sem rótulo para finalizar um loop for, while ou do-while [...]

Uma instrução de quebra sem rótulo finaliza a opção mais interna, para, enquanto, ou instruções do-while, mas uma quebra rotulada finaliza uma instrução externa.

continue

A instrução continue ignora a iteração atual de um loop for, while ou do-while. A forma não marcada pula para o final do corpo do loop mais interno e avalia a expressão booleana que controla o loop. [...]

Uma instrução continue rotulada ignora a iteração atual de um loop externo marcado com o rótulo fornecido.

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

Isso levará à seguinte saída:

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

Você pode rotular um bloco, não apenas um loop for, e depois interromper / continuar de um bloco aninhado para outro externo. Em alguns casos, isso pode ser útil, mas em geral você tentará evitar esse código, exceto que a lógica do programa é muito melhor para entender do que no exemplo a seguir:

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 é possível, isso não significa que você deve usá-lo.

Se você deseja ofuscar seu código de uma maneira engraçada, não escolhe um nome significativo, mas http: e segue-o com um comentário que parece estranho, como uma webadress no código-fonte:

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

Eu acho que isso é de uma brincadeira de Joshua Bloch. :)

Break deixa o loop completamente e executa as instruções após o loop. Enquanto Continue deixa a iteração atual e executa com o próximo valor no loop.

Este código explica tudo:

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

Resultado:

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

breaksai completamente do loop. continuepula as instruções após a instrução continue e continua em loop.

Declaração de quebra

Às vezes, é necessário sair de um loop antes que o loop termine completamente a iteração sobre todos os valores da etapa. Por exemplo, repetindo uma lista de números até encontrar um número que satisfaça uma determinada condição. Ou fazendo um loop sobre um fluxo de caracteres de um arquivo até que um determinado caractere seja lido.

No exemplo a seguir, estamos usando um loop for simples para imprimir valores de 0 a 9:

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

Resultado:

0
1
2
3
4
5
6
7
8
9

Agora, se adicionarmos uma instrução break quando i == 4, nosso código sairá do loop quando eu for igual a 4. Você pode usar a instrução break para sair dos loops for, enquanto loops e do-while. A declaração de interrupção interrompe apenas o loop atual. Para interromper um loop externo a partir de um loop interno aninhado, você precisará usar rótulos com a instrução break.

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

Resultado:

0
1
2
3
4

Declaração Continue

A instrução continue do Java pula a iteração atual de um loop e vai diretamente para a próxima iteração. Após chamar a instrução continue em um loop for, a execução do loop executará o valor da etapa e avaliará a condição booleana antes de prosseguir com a próxima iteração. No exemplo a seguir, estamos imprimindo todos os valores de 0 a 9 em um loop, mas pulamos a impressão 4.

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

Resultado:

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

Etiqueta de loop - Instrução de quebra Você pode usar etiquetas em loops aninhados , especificando onde deseja que a execução continue após interromper um loop interno. Normalmente, a instrução break apenas interrompe o loop mais interno; portanto, quando você deseja interromper um loop externo, pode usar rótulos para fazer isso, essencialmente fazendo algo semelhante a uma instrução goto.

O exemplo a seguir usa 3 loops, todos aninhados um no outro. Como não há como sair completamente do loop mais externo de dentro do loop mais interno, podemos usar o rótulo "outer1" para fazer isso e especificar o rótulo ao lado da instrução 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;
      }
    }
  }
}

Resultado:

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

Observe como a última linha exibida é " 0 [0]", que é onde j == 3 e é onde chamamos "break outer1;" para sair do loop mais externo.

Etiquetas de loop - Instrução Continuar

Você também pode usar rótulos com a palavra-chave continue para continuar fazendo um loop a partir de um ponto específico. Tomando o exemplo anterior e apenas alterando uma linha para especificar, em continue outer1;vez de break outer1;, o loop continuará em loop a partir do outer1rótulo, em vez de sair do loop. Observe como cada vez que continue outer1;é chamado, o código continua do loop externo depois de aumentar o índice do loop i em 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: Loops em Java - Ultimate Guide

Excelente resposta simples e precisa.

Eu adicionaria um exemplo 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

A breakdeclaração determina a resolução da declaração a que se aplica ( switch, for, doou while).

Uma continueinstrução é usada para finalizar a iteração do loop atual e retornar o controle para a instrução do loop.

continuepula o loop em execução atual e move-se para o próximo loop, enquanto break move para fora do loop e executa a próxima instrução após o loop. Aprendi a diferença usando o código a seguir. Verifique as diferentes saídas. Espero que isso ajude.

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

Considere o seguinte:

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

break faz com que o loop termine e o valor de n é 0.

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

continue faz com que o contador do programa retorne à primeira linha do loop (a condição é verificada e o valor de n é incrementado) e o valor final de n é 10.

Note-se também que break apenas finaliza a execução do loop em que está:

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

Produzirá algo com o efeito de

0
0
0
0
0
5

A breakinstrução interrompe o loop (a próxima instrução a ser executada é a primeira após a chave de fechamento), enquanto continueinicia o loop na próxima iteração.

A breakinstrução existe a estrutura de controle de loop atual e salta atrás dela enquanto as continuesaídas também, mas retornando à condição de loop.

Exemplo simples:

break sai do loop.

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

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

continue voltará para iniciar o loop.

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 impedir que algo seja executado se uma condição for atendida, deve-se usar o continue e, para sair do loop, se uma condição for atendida, deve-se usar a interrupção.

Por exemplo, no código abaixo mencionado.

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

        if(i==3){

           continue;

        }
       System.out.println(i);
     }

O código acima imprimirá o resultado: 0 1 2 4

Agora, 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

Essa é a diferença básica no continuar e quebrar.

aqui está a semântica da quebra:

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

aqui está a 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:;
}

Em primeiro lugar, acho que você deve saber que existem dois tipos de interrupção e continuação em Java que são rotulados como break, break não rotulados, rotulados continue e continue sem rótulo. Agora, falarei sobre a diferença entre eles.

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

Uma instrução de quebra sem rótulo finaliza a opção mais interna, para, enquanto, a instrução 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.
        }
    }
}

Uma quebra rotulada finaliza uma declaração externa. Se você javac e java nesta demonstração, obterá:

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

Uma instrução continue sem rótulo ignora a iteração atual de uma instrução 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
        }
    }
}

Uma instrução continue rotulada ignora a iteração atual de um loop externo marcado com a etiqueta especificada. Se você fizer javac e java na demo, obterá:

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 você tiver alguma dúvida, poderá ver o tutorial em Java sobre isso: insira a descrição do link aqui

Simplificando: break interromperá o loop atual e continuará a execução na primeira linha após o término do loop. continue salta de volta à condição do loop e continua executando o loop.

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

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

tente este código no netbeans, você entenderá a diferença entre interromper e continuar

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

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

Programa simples para entender a diferença entre continuar e interromper

Quando continueé usado

    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 breaké usado

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

Continue Statment para a itration e inicia a próxima ittration 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 para o loop ou Sair do loop

então você está dentro de um loop for ou while. Usando pausa; colocará você fora do circuito. Como em, terminará. Continuar; dirá para executar a próxima iteração.

Não faz sentido usar a instrução continue in if, mas interrompa; é útil. No switch ... case, sempre use break; para finalizar um caso, para que ele não execute outro caso.