come possiamo uscire da 4 inner for loops?

Question

Hi Sono principiante in java e il mio programma ha 4 cicli for: il mio programma funziona in questo modo che, se b è true, l'elemento verrà rimosso dalla pointList e n sarà n-- e ho voglia di uscire da tutte le per loops e vieni di nuovo dal primo ciclo for così l sarà l++, come posso fare questo? con dichiarazione di rottura?

for (int l = 0; l < n; l++) { 
    for (int i = 1; i < (n - 2); i++) { 
     for (int j = i + 1; j < (n - 1); j++) { 
      for (int k = j + 1; k < n; k++) { 
       if (l != i && l != j && l != k) { 
        boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
        System.out.println(b); 
        if (b == true) { 
         pointList.remove(pointList.get(l); 
         n--; 
         break; 
        } 
        else 
         System.out.println(b); 
       } 
      } 
     } 
    } 
} 

Answer 1

Si può fare uso di una rottura etichettato come:

 for (int l = 0; l < n; l++) { 
foo: for (int i = 1; i < (n - 2); i++) { 
      for (int j = i + 1; j < (n - 1); j++) { 
       for (int k = j + 1; k < n; k++) { 
        if (l != i && l != j && l != k) { 
         boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
         System.out.println(b); 
         if (b == true) { 
          pointList.remove(pointList.get(l); 
          n--; 
          break foo; 
         } 
         else 
          System.out.println(b); 
        } 

       } 

      } 
     } 
    } 

Answer 2

Dai un'occhiata alla l'istruzione break etichettata

per esempio qui: Branching Statements

Answer 3

String valueFromObj2 = null; 
String valueFromObj4 = null; 
OUTERMOST: for(Object1 object1: objects){ 
    for(Object2 object2: object1){ 
    //I get some value from object2 
    valueFromObj2 = object2.getSomeValue(); 
    for(Object3 object3 : object2){ 
     for(Object4 object4: object3){ 
     //Finally I get some value from Object4. 
     valueFromObj4 = object4.getSomeValue(); 
     //Compare with valueFromObj2 to decide either to break all the foreach loop 
     if(compareTwoVariable(valueFromObj2, valueFromObj4)) { 
      break OUTERMOST; 
     } 
     }//fourth loop ends here 
    }//third loop ends here 
    }//second loop ends here 
}//first loop ends here 

Answer 4

Una prima soluzione 'rapida e sporca' sarebbe quella di utilizzare una variabile stay_into_loops e modificare il for cicli piace:

boolean stay_into_loops = true 
// here goes the first for loop 
for (int i = 1; i < (n - 2) && stay_into_loops ; i++) { 
      for (int j = i + 1; j < (n - 1) && stay_into_loops ; j++) { 
       for (int k = j + 1; k < n && stay_into_loops ; k++) { 
        if (l != i && l != j && l != k) { 
         boolean b = isOK(pointList.get(l), `pointList.get(i), pointList.get(j), pointList.get(k));` 
         System.out.println(b); 
         if (b == true) { 
          pointList.remove(pointList.get(l); 
          n--; 
          stay_into_loops = false; 
          break; 

Tuttavia è in genere un odore di codice quando si incontrano le cose come queste. Prendi in considerazione il refactoring del codice perché a un certo punto questo si trasformerà in un disastro.

Answer 5

In un ciclo l'istruzione break termina il ciclo interno mentre continue passa all'iterazione successiva. Affinché queste due istruzioni funzionino su un loop diverso da quello interno, è necessario utilizzare labels. Qualcosa del genere dovrebbe funzionare:

outerloop:  
     for (int l = 0; l < n; l++) { 
      for (int i = 1; i < (n - 2); i++) { 
       for (int j = i + 1; j < (n - 1); j++) { 
        for (int k = j + 1; k < n; k++) { 
         if (l != i && l != j && l != k) { 
          boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
          System.out.println(b); 
          if (b == true) { 
           pointList.remove(pointList.get(l); 
           n--; 
           continue outerloop; 
          } 
          else 
           System.out.println(b); 
         } 

        } 

       } 
      } 
     } 

Answer 6

utilizzare un ciclo etichettato

for (int l = 0; l < n; l++) { 
    loopa: 
    for (int i = 1; i < (n - 2); i++) { 
     for (int j = i + 1; j < (n - 1); j++) { 
      for (int k = j + 1; k < n; k++) { 
       if (l != i && l != j && l != k) { 
        boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
        System.out.println(b); 
        if (b == true) { 
         pointList.remove(pointList.get(l); 
         n--; 
         break loopa; 
        } 
        else 
         System.out.println(b); 
       } 

      } 

     } 
    } 
} 

e poi pausa dal ciclo etichettato

Answer 7

Crea un uscita per se stessi in ogni ciclo for interno.
Ecco una soluzione rapida e indolore.

bool breakout; 
    for (int l = 0; l < n; l++) 
    { 
     breakout = false; 
     for (int i = 1; i < (n - 2) && !breakout; i++) 
      for (int j = i + 1; j < (n - 1) && !breakout; j++) 
       for (int k = j + 1; k < n && !breakout; k++) 
       { 
        if(b == true) 
         breakout = true;        
       } 
    } 

in modo da vedere il booleano breakout è il vostro biglietto da ogni ciclo interno, coz viene controllato in ogni dichiarazione for. E si resetta ogni volta che il primo for itera.

Answer 8

again: 
for (int l = 0; l < n; l++) { 
     for (int i = 1; i < (n - 2); i++) { 
      for (int j = i + 1; j < (n - 1); j++) { 
       for (int k = j + 1; k < n; k++) { 
        if (l != i && l != j && l != k) { 
         boolean b = isOK(pointList.get(l), pointList.get(i), pointList.get(j), pointList.get(k)); 
         System.out.println(b); 
         if (b == true) { 
          pointList.remove(pointList.get(l); 
          n--; 
          break again; 
         } 
         else 
          System.out.println(b); 
        } 

       } 

      } 
     } 
    } 

Answer 9

Sono d'accordo con tutte le altre risposte. Tuttavia, vorrei sottolineare che un'alternativa a exit sarebbe quella di inserire il codice nella propria routine e utilizzare un'istruzione return per uscire dall'intera cosa. Il tuo ciclo quad-nest è così complesso di per sé che probabilmente merita comunque di essere nella sua routine.

Ho lavorato a lavori DoD che richiedevano uno cyclomatic complexity di non più di 6 per una qualsiasi routine (con alcune eccezioni). Questa serie di loop da sola è 4. Se non riesci a trovare un modo più semplice per farlo, dovresti proprio metterli nella loro routine solo per preservare la sanità mentale dei poveri schmuck che devono mantenere questo codice.