Różnica między instrukcją break a continu

Czy ktoś może mi powiedzieć różnicę między breaki continuestwierdzeniami?

breakpozostawia pętlę, continueprzeskakuje do następnej iteracji.

Zobacz Instrukcje rozgałęziania, aby uzyskać więcej szczegółów i przykładów kodu:

break

Instrukcja break ma dwie formy: etykietowane i nieznakowane. Widziałeś nieznakowaną formę w poprzedniej dyskusji instrukcji switch. Możesz także użyć nieoznaczonej przerwy, aby zakończyć pętlę for, while lub do-while [...]

Nieznakowana instrukcja break przerywa najbardziej wewnętrzny przełącznik dla instrukcji „while” lub „do-while”, ale przerwa oznaczona etykietą kończy instrukcję zewnętrzną.

continue

Instrukcja Continue pomija bieżącą iterację pętli for, while lub do-while. Nieoznakowana postać przeskakuje na koniec najbardziej wewnętrznej części pętli i ocenia wyrażenie logiczne, które kontroluje pętlę. [...]

Oznaczona instrukcja kontynuuje pomijanie bieżącej iteracji zewnętrznej pętli oznaczonej podaną etykietą.

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

Doprowadzi to do następujących wyników:

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

Możesz opisać blok, nie tylko pętlę for, a następnie przerwać / kontynuować z bloku zagnieżdżonego do zewnętrznego. W kilku przypadkach może to być przydatne, ale ogólnie starasz się unikać takiego kodu, z tym wyjątkiem, że logika programu jest znacznie lepsza do zrozumienia niż w poniższym przykładzie:

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

Ponieważ jest to możliwe, nie oznacza to, że powinieneś go używać.

Jeśli chcesz zaciemnić swój kod w zabawny sposób, nie wybierasz złośliwej nazwy, ale http: i podążaj za nią z komentarzem, który wygląda obco, jak adres internetowy w kodzie źródłowym:

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

To chyba z quizu Joshua Blocha. :)

Break całkowicie opuszcza pętlę i wykonuje instrukcje po pętli. Natomiast Continue pozostawia bieżącą iterację i wykonuje z następną wartością w pętli.

Ten kod wyjaśnia wszystko:

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

Wynik:

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

breakcałkowicie wychodzi z pętli. continuepomija instrukcje po instrukcji Kontynuuj i kontynuuje zapętlanie.

Oświadczenie o złamaniu

Czasami konieczne jest wyjście z pętli, zanim pętla zakończy w pełni iterację wszystkich wartości kroku. Na przykład zapętlanie listy numerów, aż znajdziesz liczbę spełniającą określony warunek. Lub zapętlanie strumienia znaków z pliku, aż określony znak zostanie odczytany.

W poniższym przykładzie używamy prostej pętli for, aby wydrukować wartości od 0 do 9:

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

Wynik:

0
1
2
3
4
5
6
7
8
9

Teraz, jeśli dodamy instrukcję break, gdy i == 4, nasz kod wyrwie się z pętli, gdy i wyniesie 4. Możesz użyć instrukcji break do wyrwania się z pętli for, while i pętli do-while. Instrukcja break wyłamie się tylko z bieżącej pętli. Aby oderwać się od zewnętrznej pętli od zagnieżdżonej pętli wewnętrznej, należy użyć etykiet z instrukcją break.

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

Wynik:

0
1
2
3
4

Kontynuuj Instrukcja

Instrukcja kontynuacji Java pomija bieżącą iterację pętli i przechodzi bezpośrednio do następnej iteracji. Po wywołaniu instrukcji Continue w pętli for, wykonanie pętli wykona wartość kroku i oceni warunek logiczny przed przejściem do następnej iteracji. W poniższym przykładzie wypisujemy wszystkie wartości od 0 do 9 w pętli, ale pomijamy drukowanie 4.

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

Wynik:

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

Etykieta pętli - instrukcja Break Możesz używać etykiet w zagnieżdżonych pętlach , określając, gdzie chcesz kontynuować wykonywanie po zerwaniu z wewnętrznej pętli. Zwykle instrukcja break wyrwie się tylko z najbardziej wewnętrznej pętli, więc jeśli chcesz wyrwać się z zewnętrznej pętli, możesz użyć etykiet, aby to zrobić, zasadniczo robiąc coś podobnego do instrukcji goto.

Poniższy przykład wykorzystuje 3 pętle, wszystkie zagnieżdżone w sobie. Ponieważ nie ma możliwości całkowitego wyrwania się z najbardziej zewnętrznej pętli z wnętrza najbardziej wewnętrznej pętli, możemy użyć etykiety „outer1”, aby to osiągnąć i określić etykietę obok instrukcji 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;
      }
    }
  }
}

Wynik:

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

Zauważ, że ostatni wyświetlany wiersz to „ 0 [0]”, gdzie j == 3 i tam nazwaliśmy „break outer1;” wyrwać się z najbardziej zewnętrznej pętli.

Etykiety pętli - kontynuuj Instrukcja

Możesz także użyć etykiet ze słowem kluczowym kontynuuj, aby kontynuować zapętlanie od określonego punktu. Biorąc poprzedni przykład i po prostu zmieniając jedną linię, aby określić continue outer1;zamiast break outer1;spowoduje, że pętla będzie kontynuować zapętlanie od outer1etykiety zamiast wyłamywania się z pętli. Zwróć uwagę, jak za każdym razem continue outer1;jest wywoływany, kod jest kontynuowany z zewnętrznej pętli po zwiększeniu indeksu i o 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]

Źródło: Loops in Java - Ultimate Guide

Doskonała odpowiedź prosta i dokładna.

Dodałbym próbkę kodu.

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 breakwyniki oświadczenie na zakończenie rachunku, którego dotyczy ( switch, for, do, lub while).

continueOświadczenie jest używany do końca bieżącej iteracji pętli i zwrócić sterowanie do instrukcji pętli.

continuepomija bieżącą pętlę wykonawczą i PRZEJŚCIE do następnej pętli, natomiast break WYJŚCIE z pętli i wykonuje następną instrukcję po pętli. Nauczyłem się różnicy za pomocą następującego kodu. Sprawdź różne wyniki. Mam nadzieję, że to pomoże.

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

Rozważ następujące:

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

break powoduje zakończenie pętli, a wartość n wynosi 0.

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

Kontynuuj powoduje, że licznik programu powraca do pierwszego wiersza pętli (warunek jest sprawdzany, a wartość n jest przyrostem), a końcowa wartość n wynosi 10.

Należy również zauważyć, że przerwa tylko kończy wykonywanie pętli, w której się znajduje:

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

Wyprowadzi coś do efektu

0
0
0
0
0
5

Do breakprzerwy sprawozdanie z pętli (następna instrukcja do wykonania jest pierwszym po nawiasem zamykającym), natomiast continueuruchamia pętlę przy następnej iteracji.

breakOświadczenie istnieje obecną strukturę pętli sterowania i skacze za nim, podczas gdy continuewychodzi zbyt ale skoki z powrotem do stanu pętli.

Prosty przykład:

break opuszcza pętlę.

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

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

continue wróci do uruchomienia pętli.

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

Aby zapobiec wykonywaniu czegokolwiek, jeśli warunek jest spełniony, należy użyć kontynuacji i aby wyjść z pętli, jeśli warunek jest spełniony, należy użyć przerwy.

Na przykład w wymienionym poniżej kodzie.

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

        if(i==3){

           continue;

        }
       System.out.println(i);
     }

Powyższy kod wyświetli wynik: 0 1 2 4

Teraz weź pod uwagę ten kod

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


            if(i==3){

                break;

            }
            System.out.println(i);
         }

Ten kod wydrukuje 0 1 2

To jest podstawowa różnica w kontynuacji i przerwie.

oto semantyczna przerwa:

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

oto semantyka kontynuacji:

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

Po pierwsze, myślę, że powinieneś wiedzieć, że istnieją dwa rodzaje przerw i kontynuuj w Javie, które są oznaczone jako przerwa, przerwa bez etykiety, oznaczone kontynuacja i kontynuacja bez etykiety. Teraz porozmawiam o różnicy między nimi.

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

Nieznakowana instrukcja break kończy wewnętrzny przełącznik dla instrukcji while, 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.
        }
    }
}

Podział oznaczony etykietą kończy zewnętrzną instrukcję. Jeśli wykonasz javac i java to demo, otrzymasz:

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

Nieoznaczona instrukcja kontynuuje pomija bieżącą iterację instrukcji 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
        }
    }
}

Oznaczona instrukcja kontynuuje pomijanie bieżącej iteracji zewnętrznej pętli oznaczonej podaną etykietą, jeśli javac i java demo, otrzymasz:

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

jeśli masz jakieś pytanie, możesz zobaczyć samouczek Java tego: wprowadź opis linku tutaj

Mówiąc najprościej: break zakończy bieżącą pętlę i kontynuuje wykonywanie w pierwszej linii po zakończeniu pętli. Kontynuuj przeskakuje z powrotem do stanu pętli i kontynuuje działanie pętli.

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

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

wypróbuj ten kod w netbeans, zrozumiesz różnicę pomiędzy break i kontynuuj

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

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

Prosty program do zrozumienia różnicy między kontynuowaniem a przerwaniem

Kiedy continuejest używany

    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

Kiedy breakjest używany

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

Kontynuuj Instrukcja zatrzymaj itrację i rozpocznij następną Przykład:

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

i instrukcja Break zatrzymuje pętlę lub wychodzi z pętli

więc jesteś w pętli for lub while. Korzystanie z przerwy; sprawi, że będziesz poza pętlą. Jak w, to się skończy. Kontyntynuj; powie, aby uruchomić następną iterację.

Nie ma sensu używać kontynuacji w instrukcji if, ale break; jest przydatny. W przypadku przełącznika ... zawsze używaj break; aby zakończyć sprawę, aby nie wykonała innej sprawy.