Wie kann ich in Java aus verschachtelten Schleifen ausbrechen?

Ich habe ein verschachteltes Schleifenkonstrukt wie folgt:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             break; // Breaks out of the inner loop
         }
    }
}

Wie kann ich nun aus beiden Schleifen ausbrechen? Ich habe mir ähnliche Fragen angesehen, aber keine betrifft speziell Java. Ich konnte diese Lösungen nicht anwenden, da die meisten gotos verwendet wurden.

Ich möchte die innere Schleife nicht in eine andere Methode einfügen.

Ich möchte die Schleifen nicht erneut ausführen. Beim Brechen bin ich mit der Ausführung des Schleifenblocks fertig.

Wie bei anderen Antwortenden würde ich es definitiv vorziehen , die Schleifen in eine andere Methode zu versetzen. An diesem Punkt können Sie einfach zurückkehren, um die Iteration vollständig zu beenden. Diese Antwort zeigt nur, wie die Anforderungen in der Frage erfüllt werden können.

Sie können breakmit einem Etikett für die äußere Schleife verwenden. Zum Beispiel:

public class Test {
    public static void main(String[] args) {
        outerloop:
        for (int i=0; i < 5; i++) {
            for (int j=0; j < 5; j++) {
                if (i * j > 6) {
                    System.out.println("Breaking");
                    break outerloop;
                }
                System.out.println(i + " " + j);
            }
        }
        System.out.println("Done");
    }
}

Dies druckt:

0 0
0 1
0 2
0 3
0 4
1 0
1 1
1 2
1 3
1 4
2 0
2 1
2 2
2 3
Breaking
Done

Technisch gesehen ist die richtige Antwort, die äußere Schleife zu beschriften. In der Praxis ist es besser, den Code in eine Methode (gegebenenfalls eine statische Methode) zu externalisieren und ihn dann aufzurufen, wenn Sie an einem beliebigen Punkt innerhalb einer inneren Schleife beenden möchten.

Das würde sich für die Lesbarkeit auszahlen.

Der Code würde so etwas werden:

private static String search(...) 
{
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition) {
                // Do something and break...
                return search;
            }
        }
    }
    return null; 
}

Passend zum Beispiel für die akzeptierte Antwort:

 public class Test {
    public static void main(String[] args) {
        loop();
        System.out.println("Done");
    }

    public static void loop() {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (i * j > 6) {
                    System.out.println("Breaking");
                    return;
                }
                System.out.println(i + " " + j);
            }
        }
    }
}

Sie können einen benannten Block um die Schleifen verwenden:

search: {
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition) {
                // Do something and break...
                break search;
            }
        }
    }
}

Ich benutze niemals Etiketten. Es scheint eine schlechte Praxis zu sein, sich darauf einzulassen. Folgendes würde ich tun:

boolean finished = false;
for (int i = 0; i < 5 && !finished; i++) {
    for (int j = 0; j < 5; j++) {
        if (i * j > 6) {
            finished = true;
            break;
        }
    }
}

Sie können Etiketten verwenden:

label1: 
for (int i = 0;;) {
    for (int g = 0;;) {
      break label1;
    }
}

Verwenden Sie eine Funktion:

public void doSomething(List<Type> types, List<Type> types2){
  for(Type t1 : types){
    for (Type t : types2) {
      if (some condition) {
         // Do something and return...
         return;
      }
    }
  }
}

Sie können eine temporäre Variable verwenden:

boolean outerBreak = false;
for (Type type : types) {
   if(outerBreak) break;
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             outerBreak = true;
             break; // Breaks out of the inner loop
         }
    }
}

Abhängig von Ihrer Funktion können Sie auch die innere Schleife verlassen / verlassen:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             return;
         }
    }
}

Wenn Sie breaks und gotos nicht mögen , können Sie anstelle des for-in eine "traditionelle" for-Schleife verwenden, mit einer zusätzlichen Abbruchbedingung:

int a, b;
bool abort = false;
for (a = 0; a < 10 && !abort; a++) {
    for (b = 0; b < 10 && !abort; b++) {
        if (condition) {
            doSomeThing();
            abort = true;
        }
    }
}

Ich musste etwas Ähnliches tun, aber ich entschied mich dafür, die erweiterte for-Schleife nicht zu verwenden.

int s = type.size();
for (int i = 0; i < s; i++) {
    for (int j = 0; j < t.size(); j++) {
        if (condition) {
            // do stuff after which you want 
            // to completely break out of both loops
            s = 0; // enables the _main_ loop to terminate
            break;
        }
    }
}

Ich bevorzuge es, den Schleifentests einen expliziten "Exit" hinzuzufügen. Es macht jedem Gelegenheitsleser klar, dass die Schleife möglicherweise vorzeitig endet.

boolean earlyExit = false;
for(int i = 0 ; i < 10 && !earlyExit; i++) {
     for(int j = 0 ; i < 10 && !earlyExit; j++) { earlyExit = true; }
}

Java 8- StreamLösung:

List<Type> types1 = ...
List<Type> types2 = ...

types1.stream()
      .flatMap(type1 -> types2.stream().map(type2 -> new Type[]{type1, type2}))
      .filter(types -> /**some condition**/)
      .findFirst()
      .ifPresent(types -> /**do something**/);

Normalerweise kommt es in solchen Fällen zu einer aussagekräftigeren Logik, zum Beispiel zum Suchen oder Manipulieren einiger der fraglichen iterierten 'for'-Objekte, daher verwende ich normalerweise den funktionalen Ansatz:

public Object searching(Object[] types) { // Or manipulating
    List<Object> typesReferences = new ArrayList<Object>();
    List<Object> typesReferences2 = new ArrayList<Object>();

    for (Object type : typesReferences) {
        Object o = getByCriterion(typesReferences2, type);
        if(o != null) return o;
    }
    return null;
}

private Object getByCriterion(List<Object> typesReferences2, Object criterion) {
    for (Object typeReference : typesReferences2) {
        if(typeReference.equals(criterion)) {
             // here comes other complex or specific logic || typeReference.equals(new Object())
             return typeReference;
        }
    }
    return null;
}

Hauptnachteile:

• ungefähr zweimal mehr Zeilen
• Mehr Verbrauch von Rechenzyklen, was bedeutet, dass es aus algorithmischer Sicht langsamer ist
• mehr Schreibarbeit

Die Profis:

• das höhere Verhältnis zur Trennung von Bedenken aufgrund der funktionellen Granularität
• das höhere Verhältnis von Wiederverwendbarkeit und Kontrolle der Such- / Manipulationslogik ohne
• Die Methoden sind nicht lang, daher kompakter und leichter zu verstehen
• höheres Lesbarkeitsverhältnis

Es geht also nur darum, den Fall über einen anderen Ansatz zu behandeln.

Grundsätzlich eine Frage an den Autor dieser Frage: Was halten Sie von diesem Ansatz?

Sie können alle Schleifen ohne Verwendung von label: und Flags unterbrechen.

Es ist nur eine knifflige Lösung.

Hier ist Bedingung1 die Bedingung, die verwendet wird, um von Schleife K und J zu brechen. Und Bedingung2 ist die Bedingung, die verwendet wird, um von Schleife K, J und I zu brechen.

Zum Beispiel:

public class BreakTesting {
    public static void main(String[] args) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                for (int k = 0; k < 9; k++) {
                    if (condition1) {
                        System.out.println("Breaking from Loop K and J");
                        k = 9;
                        j = 9;
                    }
                    if (condition2) {
                        System.out.println("Breaking from Loop K, J and I");
                        k = 9;
                        j = 9;
                        i = 9;
                    }
                }
            }
        }
        System.out.println("End of I , J , K");
    }
}

Das Konzept der beschrifteten Unterbrechung wird verwendet, um verschachtelte Schleifen in Java auszubrechen. Mit der Bezeichnung der beschrifteten Unterbrechung können Sie die Verschachtelung von Schleifen an jeder Position aufheben. Beispiel 1:

loop1:
 for(int i= 0; i<6; i++){
    for(int j=0; j<5; j++){
          if(i==3)
            break loop1;
        }
    }

Angenommen, es gibt 3 Schleifen und Sie möchten die Schleife beenden3: Beispiel 2:

loop3: 
for(int i= 0; i<6; i++){
loop2:
  for(int k= 0; k<6; k++){
loop1:
    for(int j=0; j<5; j++){
          if(i==3)
            break loop3;
        }
    }
}

boolean broken = false; // declared outside of the loop for efficiency
for (Type type : types) {
    for (Type t : types2) {
        if (some condition) {
            broken = true;
            break;
        }
    }

    if (broken) {
        break;
    }
}

Wenn es sich in einer Funktion befindet, warum geben Sie es nicht einfach zurück:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
            return value;
         }
    }
}

Beste und einfachste Methode ..

outerloop:
for(int i=0; i<10; i++){
    // here we can break Outer loop by 
    break outerloop;

    innerloop:
    for(int i=0; i<10; i++){
        // here we can break innerloop by 
        break innerloop;
     }
}

Eher ungewöhnlicher Ansatz, aber in Bezug auf die Codelänge ( nicht die Leistung ) ist dies das Einfachste, was Sie tun können:

for(int i = 0; i++; i < j) {
    if(wanna exit) {
        i = i + j; // if more nested, also add the 
                   // maximum value for the other loops
    }
}

Verwenden Sie Etiketten.

INNER:for(int j = 0; j < numbers.length; j++) {
    System.out.println("Even number: " + i + ", break  from INNER label");
    break INNER;
}

Siehe diesen Artikel

Eine andere Lösung, die ohne Beispiel erwähnt wird (sie funktioniert tatsächlich im Produktcode).

try {
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition #1) {
                // Do something and break the loop.
                throw new BreakLoopException();
            }
        }
    }
}
catch (BreakLoopException e) {
    // Do something on look breaking.
}

Natürlich BreakLoopExceptionsollte es intern, privat und mit No-Stack-Trace beschleunigt sein:

private static class BreakLoopException extends Exception {
    @Override
    public StackTraceElement[] getStackTrace() {
        return new StackTraceElement[0];
    }
}

for (int j = 0; j < 5; j++) //inner loop sollte durch ersetzt werden for (int j = 0; j < 5 && !exitloops; j++) .

In diesem Fall sollten vollständige verschachtelte Schleifen beendet werden, wenn die Bedingung erfüllt ist True. Aber wenn wir exitloopsnur nach oben verwendenloop

 for (int i = 0; i < 5 && !exitloops; i++) //upper loop

Dann wird die innere Schleife fortgesetzt, da es kein zusätzliches Flag gibt, das diese innere Schleife zum Verlassen benachrichtigt.

Beispiel: Wenn i = 3und j=2Dann ist die Bedingung false. Aber in der nächsten Iteration der inneren Schleife j=3 wird der Zustand (i*j), 9der truenur die innere Schleife ist, fortgesetzt, bis er jwird 5.

Es muss also auch exitloopsfür die inneren Schleifen verwendet werden.

boolean exitloops = false;
for (int i = 0; i < 5 && !exitloops; i++) { //here should exitloops as a Conditional Statement to get out from the loops if exitloops become true. 
    for (int j = 0; j < 5 && !exitloops; j++) { //here should also use exitloops as a Conditional Statement. 
        if (i * j > 6) {
            exitloops = true;
            System.out.println("Inner loop still Continues For i * j is => "+i*j);
            break;
        }
        System.out.println(i*j);
    }
}

Verwenden Sie wie im Vorschlag für @ 1800 INFORMATION die Bedingung, die die innere Schleife unterbricht, als Bedingung für die äußere Schleife:

boolean hasAccess = false;
for (int i = 0; i < x && hasAccess == false; i++){
    for (int j = 0; j < y; j++){
        if (condition == true){
            hasAccess = true;
            break;
        }
    }
}

Wenn es sich um eine neue Implementierung handelt, können Sie versuchen, die Logik als if-else_if-else-Anweisungen neu zu schreiben.

while(keep_going) {

    if(keep_going && condition_one_holds) {
        // Code
    }
    if(keep_going && condition_two_holds) {
        // Code
    }
    if(keep_going && condition_three_holds) {
        // Code
    }
    if(keep_going && something_goes_really_bad) {
        keep_going=false;
    }
    if(keep_going && condition_four_holds) {
        // Code
    }
    if(keep_going && condition_five_holds) {
        // Code
    }
}

Andernfalls können Sie versuchen, ein Flag zu setzen, wenn diese spezielle Bedingung aufgetreten ist, und in jeder Ihrer Schleifenbedingungen nach diesem Flag suchen.

something_bad_has_happened = false;
while(something is true && !something_bad_has_happened){
    // Code, things happen
    while(something else && !something_bad_has_happened){
        // Lots of code, things happens
        if(something happened){
            -> Then control should be returned ->
            something_bad_has_happened=true;
            continue;
        }
    }
    if(something_bad_has_happened) { // The things below will not be executed
        continue;
    }

    // Other things may happen here as well, but they will not be executed
    //  once control is returned from the inner cycle.
}

HIER! Während eine einfache Pause nicht funktioniert, kann sie mit verwendet werden continue.

Wenn Sie einfach die Logik von einer Programmiersprache nach Java portieren und nur das Ding zum Laufen bringen möchten, können Sie versuchen, Labels zu verwenden .

Demo für break, continueund label:

Java-Schlüsselwörter breakundcontinue haben einen Standardwert. Es ist die "nächste Schleife", und heute, nach ein paar Jahren mit Java, habe ich sie gerade bekommen!

Es scheint selten verwendet zu werden, aber nützlich.

import org.junit.Test;

/**
 * Created by cui on 17-5-4.
 */

public class BranchLabel {
    @Test
    public void test() {
        System.out.println("testBreak");
        testBreak();

        System.out.println("testBreakLabel");
        testBreakLabel();

        System.out.println("testContinue");
        testContinue();
        System.out.println("testContinueLabel");
        testContinueLabel();
    }

    /**
     testBreak
     a=0,b=0
     a=0,b=1
     a=1,b=0
     a=1,b=1
     a=2,b=0
     a=2,b=1
     a=3,b=0
     a=3,b=1
     a=4,b=0
     a=4,b=1
     */
    public void testBreak() {
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                if (b == 2) {
                    break;
                }
                System.out.println("a=" + a + ",b=" + b);
            }
        }
    }

    /**
     testContinue
     a=0,b=0
     a=0,b=1
     a=0,b=3
     a=0,b=4
     a=1,b=0
     a=1,b=1
     a=1,b=3
     a=1,b=4
     a=2,b=0
     a=2,b=1
     a=2,b=3
     a=2,b=4
     a=3,b=0
     a=3,b=1
     a=3,b=3
     a=3,b=4
     a=4,b=0
     a=4,b=1
     a=4,b=3
     a=4,b=4
     */
    public void testContinue() {
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                if (b == 2) {
                    continue;
                }
                System.out.println("a=" + a + ",b=" + b);
            }
        }
    }

    /**
     testBreakLabel
     a=0,b=0,c=0
     a=0,b=0,c=1
     * */
    public void testBreakLabel() {
        anyName:
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                for (int c = 0; c < 5; c++) {
                    if (c == 2) {
                        break anyName;
                    }
                    System.out.println("a=" + a + ",b=" + b + ",c=" + c);
                }
            }
        }
    }

    /**
     testContinueLabel
     a=0,b=0,c=0
     a=0,b=0,c=1
     a=1,b=0,c=0
     a=1,b=0,c=1
     a=2,b=0,c=0
     a=2,b=0,c=1
     a=3,b=0,c=0
     a=3,b=0,c=1
     a=4,b=0,c=0
     a=4,b=0,c=1
     */
    public void testContinueLabel() {
        anyName:
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                for (int c = 0; c < 5; c++) {
                    if (c == 2) {
                        continue anyName;
                    }
                    System.out.println("a=" + a + ",b=" + b + ",c=" + c);
                }
            }
        }
    }
}

Demo

public static void main(String[] args) {
    outer:
    while (true) {
        while (true) {
            break outer;
        }
    }
}

Sie können Folgendes tun:

1. Setzen Sie eine lokale Variable auf false

2. Setzen Sie diese Variable truein der ersten Schleife, wenn Sie brechen möchten

3. Dann können Sie in der äußeren Schleife überprüfen, ob die Bedingung gesetzt ist, und dann auch von der äußeren Schleife abbrechen.

   boolean isBreakNeeded = false;
   for (int i = 0; i < some.length; i++) {
       for (int j = 0; j < some.lengthasWell; j++) {
           //want to set variable if (){
           isBreakNeeded = true;
           break;
       }
   
       if (isBreakNeeded) {
           break; //will make you break from the outer loop as well
       }
   }

In einigen Fällen können wir die whileSchleife hier effektiv verwenden.

Random rand = new Random();
// Just an example
for (int k = 0; k < 10; ++k) {
    int count = 0;
    while (!(rand.nextInt(200) == 100)) {
       count++;
    }

    results[k] = count;
}

Java hat keine Goto-Funktion wie in C ++. Dennoch gotoist ein reserviertes Schlüsselwort in Java. Sie könnten es in Zukunft implementieren. Auf Ihre Frage lautet die Antwort, dass es in Java ein sogenanntes Label gibt, auf das Sie eine continueand- breakAnweisung anwenden können . Finden Sie den Code unten:

public static void main(String ...args) {
    outerLoop: for(int i=0;i<10;i++) {
    for(int j=10;j>0;j--) {
        System.out.println(i+" "+j);
        if(i==j) {
            System.out.println("Condition Fulfilled");
            break outerLoop;
        }
    }
    }
    System.out.println("Got out of the outer loop");
}

Sogar das Erstellen eines Flags für die äußere Schleife und das Überprüfen, ob nach jeder Ausführung der inneren Schleife die Antwort sein kann.

So was:

for (Type type : types) {
    boolean flag=false;
    for (Type t : types2) {
        if (some condition) {
            // Do something and break...
            flag=true;
            break; // Breaks out of the inner loop
        }
    }
    if(flag)
        break;
}

boolean condition = false;
for (Type type : types) {
    for (int i = 0; i < otherTypes.size && !condition; i ++) {
        condition = true; // If your condition is satisfied
    }
}

Verwenden Sie conditionals Flag für , wenn Sie fertig Verarbeitung sind. Dann wird die innere Schleife nur fortgesetzt, solange die Bedingung nicht erfüllt ist. In jedem Fall wird die äußere Schleife weiter tuckern.