Come uscire dai loop nidificati in Java?

Ho un costrutto di loop nidificato come questo:

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

Ora come posso uscire da entrambi i loop? Ho esaminato domande simili, ma nessuna riguarda Java in particolare. Non ho potuto applicare queste soluzioni perché le goto più utilizzate.

Non voglio mettere il ciclo interno in un metodo diverso.

Non voglio rieseguire i loop. Quando si rompe ho finito con l'esecuzione del loop loop.

Come altri answerers, mi piacerebbe sicuramente preferisco mettere i loop in un metodo diverso, a quel punto si può solo tornare a fermare l'iterazione completamente. Questa risposta mostra solo come possono essere soddisfatti i requisiti della domanda.

È possibile utilizzare breakcon un'etichetta per il ciclo esterno. Per esempio:

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

Questo stampa:

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

Tecnicamente la risposta corretta è etichettare il circuito esterno. In pratica, se si desidera uscire in qualsiasi punto all'interno di un ciclo interno, sarebbe meglio esternalizzare il codice in un metodo (un metodo statico se necessario) e quindi chiamarlo.

Sarebbe ripagato per la leggibilità.

Il codice diventerebbe qualcosa del genere:

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

Corrisponde all'esempio per la risposta accettata:

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

È possibile utilizzare un blocco denominato attorno ai loop:

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

Non uso mai le etichette. Sembra una cattiva pratica per entrare. Ecco cosa farei:

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

Puoi usare le etichette:

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

Usa una funzione:

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

Puoi usare una variabile temporanea:

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

A seconda della tua funzione, puoi anche uscire / tornare dal loop interno:

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

Se non ti piacciono le breaks e gotos, puoi usare un ciclo "tradizionale" al posto del for-in, con una condizione di interruzione extra:

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

Avevo bisogno di fare una cosa simile, ma ho scelto di non usare il ciclo avanzato for per farlo.

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

Preferisco aggiungere una "uscita" esplicita ai test di loop. Rende chiaro a qualsiasi lettore occasionale che il loop potrebbe terminare in anticipo.

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

StreamSoluzione Java 8 :

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

Di solito in questi casi, rientra nell'ambito di una logica più significativa, diciamo un po 'di ricerca o manipolazione su alcuni degli oggetti' for 'iterati in questione, quindi di solito uso l'approccio funzionale:

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

Principali svantaggi:

• circa due volte più righe
• maggiore consumo di cicli di calcolo, il che significa che è più lento dal punto di vista algoritmico
• più lavoro di battitura

I pro:

• il rapporto più elevato con la separazione delle preoccupazioni a causa della granularità funzionale
• il rapporto più elevato di riutilizzabilità e controllo della ricerca / manipolazione della logica senza
• i metodi non sono lunghi, quindi sono più compatti e più facili da comprendere
• rapporto più elevato di leggibilità

Quindi sta semplicemente gestendo il caso con un approccio diverso.

Fondamentalmente una domanda all'autore di questa domanda: cosa pensi di questo approccio?

È possibile interrompere da tutti i loop senza utilizzare alcuna etichetta: e flag.

È solo una soluzione complicata.

Qui condition1 è la condizione che viene utilizzata per interrompere dal loop K e J. E condition2 è la condizione che viene utilizzata per interrompere dal loop K, J e I.

Per esempio:

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

Il concetto di interruzione etichettata viene utilizzato per suddividere gli anelli nidificati in Java, utilizzando l'interruzione etichettata è possibile interrompere l'annidamento degli anelli in qualsiasi posizione. Esempio 1:

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

supponiamo che ci siano 3 loop e desideri terminare il loop3: Esempio 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;
    }
}

Se è all'interno di una funzione, perché non la restituisci semplicemente:

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

Metodo migliore e facile ..

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

Approccio piuttosto insolito ma in termini di lunghezza del codice ( non prestazioni ) questa è la cosa più semplice che potresti fare:

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

Usa etichette.

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

Fare riferimento a questo articolo

Un'altra soluzione, menzionata senza esempio (in realtà funziona nel codice prodotto).

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

Naturalmente BreakLoopExceptiondovrebbe essere interno, privato e accelerato con no-stack-trace:

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

for (int j = 0; j < 5; j++) //inner loopdovrebbe essere sostituito con for (int j = 0; j < 5 && !exitloops; j++).

Qui, in questo caso, i loop nidificati completi dovrebbero essere usciti se la condizione lo è True. Ma se usiamo exitloopssolo verso l'altoloop

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

Quindi il ciclo interno continuerà, perché non vi è alcun flag aggiuntivo che notifica l'uscita di questo ciclo interno.

Esempio: if i = 3e j=2quindi condition è false. Ma nella successiva iterazione del ciclo interno, j=3 allora la condizione (i*j)diventa 9che è, truema il ciclo interno continuerà fino a jdiventare 5.

Quindi, deve usare anche exitloopsper gli anelli interni.

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

Come suggerimento @ 1800 INFORMATION, utilizzare la condizione che interrompe il loop interno come condizione sul loop esterno:

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

Se si tratta di una nuova implementazione, puoi provare a riscrivere la logica come istruzioni if-else_if-else.

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

Altrimenti puoi provare a impostare una bandiera quando si è verificata quella condizione speciale e verificare la presenza di quella bandiera in ciascuna delle tue condizioni di loop.

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

QUI! Quindi, mentre una semplice interruzione non funzionerà, può essere fatta funzionare con continue.

Se stai semplicemente eseguendo il porting della logica da un linguaggio di programmazione a Java e vuoi solo far funzionare la cosa, puoi provare a usare le etichette .

Demo per break, continueelabel :

Parole chiave Java breakecontinue hanno un valore predefinito. È il "ciclo più vicino" e oggi, dopo alcuni anni di utilizzo di Java, l'ho appena preso!

Sembra usato raro, ma utile.

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

dimostrazione

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

Puoi fare quanto segue:

1. imposta una variabile locale su false

2. impostare quella variabile truenel primo ciclo, quando si desidera interrompere

3. quindi è possibile verificare nel loop esterno che se la condizione è impostata si interrompa anche dal loop esterno.

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

Per alcuni casi, possiamo usare il whileloop in modo efficace qui.

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 non ha una funzione goto come in C ++. Tuttavia, gotoè una parola chiave riservata in Java. Potrebbero implementarlo in futuro. Per la tua domanda, la risposta è che esiste qualcosa chiamato etichetta in Java a cui puoi applicare una continuee break. Trova il codice qui sotto:

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

Anche creando un flag per il loop esterno e verificando che dopo ogni esecuzione del loop interno possa essere la risposta.

Come questo:

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

Utilizzare conditioncome flag per quando l'elaborazione è terminata. Quindi il ciclo interno continua solo quando la condizione non è stata soddisfatta. Ad ogni modo, il circuito esterno continuerà a funzionare.