Wie kann ich in Java aus verschachtelten Schleifen ausbrechen?

Question

Ich habe ein verschachteltes Schleifenkonstrukt wie dieses:

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 davon betrifft speziell Java. Ich konnte diese Lösungen nicht anwenden, weil die meisten gotos verwendeten.

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

Ich möchte die Schleifen nicht zurückgeben. Beim Abbrechen bin ich mit der Ausführung des Schleifenblocks fertig.

Answer 1

Ich ziehe es vor, den Schleifentests einen expliziten "Ausgang" hinzuzufügen. Das macht jedem dass die Schleife vorzeitig abgebrochen werden kann.

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

Answer 2

Beschriftete Pause Konzept wird verwendet, um verschachtelte Schleifen in Java aufzubrechen. Durch die Verwendung von labeled break können Sie die Verschachtelung von Schleifen an jeder beliebigen Position aufbrechen. Beispiel 1:

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

Nehmen wir an, es gibt 3 Schleifen und Sie wollen die Schleife3 beenden: 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;
        }
    }
}

Answer 3

Java 8 Stream Lö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**/);

Answer 4

Normalerweise kommt es in solchen Fällen im Rahmen von mehr sinnvolle Logik, sagen wir einige Suche oder Manipulation über einige der iterierten 'for'-Objekte in Frage, so dass ich in der Regel die funktionale Ansatz verwenden:

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

Große Nachteile:

• etwa doppelt so viele Zeilen
• höherer Verbrauch von Rechenzyklen, d.h. aus algorithmischer Sicht ist es langsamer
• mehr Schreibarbeiten

Die Vorteile:

• das höhere Verhältnis zur Trennung von Belangen aufgrund der funktionalen Granularität
• der höhere Anteil an Wiederverwendbarkeit und Kontrolle von Such-/Manipulationslogik ohne
• die Methoden sind nicht lang, daher sind sie kompakter und leichter zu verstehen
• höherer Grad der Lesbarkeit

Sie behandelt den Fall also einfach auf eine andere Art und Weise.

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

Answer 5

Demo

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