¿Cómo salgo de los bucles anidados en Java?

Tengo una construcción de bucle anidado como esta:

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

Ahora, ¿cómo puedo salir de ambos bucles? He examinado preguntas similares, pero ninguna se refiere específicamente a Java. No pude aplicar estas soluciones porque la mayoría usaba gotos.

No quiero poner el bucle interno en un método diferente.

No quiero volver a ejecutar los bucles. Cuando rompo, termino con la ejecución del bloque de bucle.

Al igual que otros respondedores, definitivamente preferiría poner los bucles en un método diferente, momento en el que puede regresar para dejar de iterar por completo. Esta respuesta solo muestra cómo se pueden cumplir los requisitos de la pregunta.

Puede usar breakcon una etiqueta para el bucle externo. Por ejemplo:

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

Esto imprime:

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

Técnicamente, la respuesta correcta es etiquetar el bucle externo. En la práctica, si desea salir en cualquier punto dentro de un bucle interno, será mejor que externalice el código en un método (un método estático si es necesario) y luego lo llame.

Eso pagaría por la legibilidad.

El código se convertiría en algo así:

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

Emparejando el ejemplo para la respuesta aceptada:

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

Puede usar un bloque con nombre alrededor de los bucles:

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

Nunca uso etiquetas. Parece una mala práctica entrar. Esto es lo que haría:

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

Puedes usar etiquetas:

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

Usa una función:

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

Puedes usar una variable temporal:

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

Dependiendo de su función, también puede salir / regresar desde el bucle interno:

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

Si no le gusta breaksy gotos, puede usar un bucle for "tradicional" en lugar del for-in, con una condición de aborto adicional:

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

Necesitaba hacer algo similar, pero elegí no usar el bucle mejorado para hacerlo.

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

Prefiero agregar una "salida" explícita a las pruebas de bucle. Le deja claro a cualquier lector casual que el ciclo puede terminar antes de tiempo.

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

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

Por lo general, en tales casos, se trata de una lógica más significativa, digamos algunas búsquedas o manipulaciones sobre algunos de los objetos 'for' iterados en cuestión, por lo que generalmente uso el enfoque funcional:

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

Contras principales:

• aproximadamente dos veces más líneas
• mayor consumo de ciclos informáticos, lo que significa que es más lento desde el punto de vista algorítmico
• más trabajo de mecanografía

Los profesionales:

• la mayor proporción de separación de preocupaciones debido a la granularidad funcional
• la mayor proporción de reutilización y control de la lógica de búsqueda / manipulación sin
• los métodos no son largos, por lo tanto, son más compactos y más fáciles de comprender
• mayor proporción de legibilidad

Por lo tanto, solo se trata del caso a través de un enfoque diferente.

Básicamente una pregunta al autor de esta pregunta: ¿qué considera usted de este enfoque?

Puede romper todos los bucles sin usar ninguna etiqueta: y banderas.

Es solo una solución complicada.

Aquí, la condición 1 es la condición que se usa para romper el bucle K y J. Y la condición 2 es la condición que se usa para romper el bucle K, J e I.

Por ejemplo:

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

El concepto de ruptura etiquetada se usa para dividir bucles anidados en Java, al usar la rotura rotulada puede romper la anidación de bucles en cualquier posición. Ejemplo 1:

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

supongamos que hay 3 bucles y desea terminar el bucle3: Ejemplo 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;
    }
}

Si está dentro de alguna función, ¿por qué no la devuelve?

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

Método mejor y más fácil.

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

Enfoque bastante inusual, pero en términos de longitud del código ( no de rendimiento ), esto es lo más fácil que puede hacer:

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

Use etiquetas.

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

Consulte este articulo

Otra solución, mencionada sin ejemplo (en realidad funciona en código prod).

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

Por supuesto, BreakLoopExceptiondebe ser interno, privado y acelerado 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 loopdebe sustituirse por for (int j = 0; j < 5 && !exitloops; j++).

Aquí, en este caso, los bucles anidados completos deben salir si la condición es True. Pero si usamos exitloopssolo para la parte superiorloop

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

Luego, el bucle interno continuará, porque no hay un indicador adicional que notifique que este bucle interno salga.

Ejemplo: si i = 3y j=2luego la condición es false. Pero en la próxima iteración del ciclo interno, j=3 entonces la condición se (i*j)convierte en lo 9que es, truepero el ciclo interno continuará hasta jconvertirse 5.

Por lo tanto, también debe usarse exitloopsen los bucles internos.

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

Como en la sugerencia de información de 1800, use la condición que rompe el bucle interno como una condición en el bucle externo:

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

Si se trata de una nueva implementación, puede intentar reescribir la lógica como declaraciones 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
    }
}

De lo contrario, puede intentar establecer un indicador cuando se haya producido esa condición especial y verificar ese indicador en cada una de sus condiciones de bucle.

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

¡AQUÍ! Así, mientras que una ruptura simple no va a funcionar, se puede hacer el trabajo usando continue.

Si simplemente está transfiriendo la lógica de un lenguaje de programación a Java y solo quiere que funcione, puede intentar usar etiquetas .

Demo para break, continuey label:

Palabras clave de Java breaky continuetienen un valor predeterminado. Es el "ciclo más cercano", y hoy, después de unos años de usar Java, ¡lo acabo de obtener!

Parece usado raramente, pero útil.

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

Manifestación

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

Puedes hacer lo siguiente:

1. establecer una variable local en false

2. establezca esa variable trueen el primer bucle, cuando quiera romper

3. entonces puede verificar en el bucle externo, que si la condición está establecida, también se separará del bucle externo.

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

Para algunos casos, podemos usar el whilebucle de manera efectiva aquí.

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 no tiene una función de ir a Goto como la hay en C ++. Pero aún así, gotoes una palabra clave reservada en Java. Podrían implementarlo en el futuro. Para su pregunta, la respuesta es que hay algo llamado etiqueta en Java al que puede aplicar una declaración continuey break. Encuentra el código a continuación:

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

Incluso crear una bandera para el ciclo externo y verificar que después de cada ejecución del ciclo interno puede ser la respuesta.

Me gusta esto:

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

Úselo conditioncomo una bandera para cuando haya terminado de procesar. Luego, el bucle interno solo continúa mientras la condición no se ha cumplido. De cualquier manera, el bucle externo seguirá chuggin '.