¿cómo podemos salir de 4 internos para bucles?

Question

Hola soy principiante en java y mi programa tiene 4 para bucles: mi programa funciona así que si b es true, el elemento se eliminará de PointList y n será n-- y quiero salir de todo para los bucles y vienen de nuevo desde el primer bucle para l será l++, ¿cómo puedo hacer esto? con declaración de interrupción?

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

Puede hacer uso de un descanso etiquetado como:

 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

Tenga una mirada en la sentencia break etiquetado

por ejemplo aquí: 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 primera La solución 'rápida y sucia' sería usar una variable stay_into_loops y modificar el for bucles como:

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; 

Sin embargo, en general es un olor a código cuando te encuentras con cosas como estas. Considere refactorizar el código porque esto se convertirá en un desastre en algún momento.

Answer 5

En un bucle, la instrucción break finaliza el bucle interno, mientras que continue salta a la siguiente iteración. Para que estas dos sentencias funcionen en un bucle diferente al interno, debe usar labels. Algo como esto debería funcionar:

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

utilizar un bucle etiquetado

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

      } 

     } 
    } 
} 

y luego descanso del bucle etiquetado

Answer 7

Crear una salida por sí mismo en cada ciclo for interior.
Aquí hay una solución rápida e indolora.

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

para que veas la breakout booleano es su boleto de salida de cada bucle interno, coz que se comprueba en cada declaración for. Y se restablece cada vez que se itera el primer for.

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

Acepto todas las demás respuestas. Sin embargo, me gustaría señalar que una alternativa al exit sería poner ese código en su propia rutina y usar una declaración return para salir de todo. Su bucle anidado en cuatro es tan complejo en sí mismo que probablemente merece estar en su propia rutina de todos modos.

He trabajado en trabajos DoD que requieren un cyclomatic complexity de no más de 6 para una rutina cualquiera (con algunas excepciones). Esta serie de bucles por sí sola es 4. Si no puede encontrar una forma más sencilla de hacerlo, realmente debe arrojarlos en su propia rutina solo para preservar la cordura de los pobres idiotas que tienen que mantener este código.