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

1819

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.

boutta
fuente

Respuestas:

2427

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
Jon Skeet
fuente
287
Esto hace saltar directamente después de que el bucle. ¡Intentalo! Sí, la etiqueta viene antes del bucle, pero eso es porque está etiquetando el bucle, en lugar del lugar al que desea salir. (También puede continuar con una etiqueta.)
Jon Skeet
2
Perl también permite que este sea su propio sistema de etiquetas. Creo que muchos lenguajes lo hacen, apenas me sorprende que esté en Java.
Evan Carroll
99
@Evan, esa afirmación es claramente cierta, en idiomas que prometen que es verdad. Pero Java no hace esa promesa. Si un idioma está en conflicto con sus supuestos, es posible que sean sus supuestos los que tienen la culpa. En este caso, creo que todavía tiene razón en parte: principio de la menor sorpresa WRT que muchos de los que nunca escucharon (u olvidaron) de esa forma break. Incluso entonces, las excepciones son otra excepción más conocida (lo siento). Pero todavía estaría descontento con esto si no fuera obvio (pequeños bucles, comentarios de advertencia si la etiqueta / salto aún no es lo suficientemente visible).
Steve314
66
@MuhammadBabar: outerloopes una etiqueta. No sé exactamente qué código intentaste, pero el código en mi respuesta se compila y funciona bien.
Jon Skeet
44
@NisargPatil El hecho de que esté en sonarLint no lo convierte en un olor a código. Simplemente significa que hubo un desarrollador que agregó esto a sonarLint con un picor personal para rascar, y está lleno de este tipo de reglas que solo tienen sentido cuando se abusa de él, o porque algún desarrollador tiene una cruzada de odio personal contra ellos. Los descansos y continuos etiquetados son una forma muy elegante de describir lo que quieres hacer.
john16384
403

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);
            }
        }
    }
}
Zo72
fuente
30
A veces usa varias variables locales que están fuera del ciclo interno, pasarlas todas puede parecer torpe.
Haoest
1
Entonces, ¿cómo se supone que esta solución imprima "Listo" como en la respuesta aceptada?
JohnDoe
1
@JohnDoe lo llamas y luego imprimes System.out.println ("hecho"); probar {} finalmente {} dentro del método de búsqueda también es una opción.
Zo72
2
Esta es una mejor práctica, supongo, pero ¿qué pasa si quieres continuar en lugar de romper? Las etiquetas admiten igual de bien (¡o mal!) Pero no estoy seguro de cómo convertir esta lógica para continuar.
Rob Grant
@RobertGrant Si desea continuar en lugar de romper, mueva el bucle externo fuera del loopmétodo y regrese del método para continuar.
Muhd
215

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;
            }
        }
    }
}
Joey
fuente
40
No necesita crear un nuevo bloque para usar una etiqueta.
Jon Skeet
81
No, pero hace que la intención sea mucho más clara. Vea el primer comentario sobre la respuesta aceptada.
Bombe
2
en realidad no es un bloque con nombre, después de la etiqueta puede escribir cualquier expresión Java sin etiqueta, ¿ name: if(...){...}hace que la condición con nombre? :)
La VloZ Merrill
44
Esta construcción tiene una gran ventaja sobre el etiquetado fordirecto. Puede agregar código antes del último }que se ejecutará solo si la condición nunca se cumplió.
Florian F
2
Es un bloque con nombre y no un bucle con nombre. No podría dentro de ese ciclo "continuar la búsqueda"; que es una sintaxis totalmente legal si el bucle se denomina búsqueda. Puedes romperlo, pero no puedes continuar.
Tatarize
132

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;
        }
    }
}
Elle Mundy
fuente
44
¿No debería ser esto en && !finishedlugar de || !finished? ¿Y por qué entonces usarlo breaken absoluto y no usarlo también && !finishedpara el bucle interno?
Gandalf
44
Solía breakpoder salir arbitrariamente del bucle. Si hay código después de ese ifbloque, puede breakhacerlo antes de que se ejecute. Pero tienes razón &&. Arreglado.
Elle Mundy
2
buena solución! así es exactamente como lo haría en la práctica si, por alguna razón, no es preferible ponerlo en una función adicional.
benroth
66
Existe un problema potencial si hay algo de lógica después del ciclo interno ... que continuará ejecutándose y el ciclo externo se rompe solo cuando comienza la nueva iteración ...
Karthik Karuppannan
77
No entiendo por qué uno debería hacerlo así. Las personas que trabajan con código deberían poder usar todas las características de un idioma. Entiendo que es importante escribir código que otros puedan entender, pero no restringiendo el uso de herramientas oficiales proporcionadas por un idioma y encontrar soluciones para la misma funcionalidad. ¿O quisiste decir algo más por "mala práctica"?
codepleb
107

Puedes usar etiquetas:

label1: 
for (int i = 0;;) {
    for (int g = 0;;) {
      break label1;
    }
}
simon622
fuente
44
Ten un +1 de mi parte. Simple, al punto, responde a la pregunta. No se le puede acusar de repetir una respuesta existente porque usted respondió al mismo tiempo.
Heimdall
40

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;
      }
    }
  }
}
Fortega
fuente
20

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;
         }
    }
}
Miguel Ping
fuente
77
Encuentro esta forma un poco desordenada.
Boutta
11
¿Una verificación de condición adicional cada vez que se realiza el ciclo? No, gracias.
ryandenki
15

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;
        }
    }
}
zord
fuente
2
No apto para foreach bucles.
John McClane
1
@JohnMcClane ¿Y está enviando spam en muchas respuestas a una pregunta de más de 9 años porque ...?
Quintec
12

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;
        }
    }
}
Swifty McSwifterton
fuente
No me parece genial iterar todos los elementos una vez que se rompe la condición. Por lo tanto, agregaría un descanso en el caso else.
Sobre el
@boutta No estoy seguro de cómo está llegando a esta conclusión. Una vez que la condición es verdadera, se salen ambos bucles.
Swifty McSwifterton
OK, no obtuve el papel con la manipulación de la 's' var. Pero encuentro ese tipo de mal estilo ya que s representa el tamaño. Entonces prefiero la respuesta de ddyer con vars explícitos: stackoverflow.com/a/25124317/15108
aproximadamente el
@boutta Puede cambiar sa un valor que sea menor io cambiar ia un valor mayor o igual que s, ambos deberían funcionar. Tiene razón sobre el cambio s, porque puede usarse en otro lugar más tarde, pero cambiar ino dañará, solo se asegurará de que el primero forno continúe en bucle.
Zsolti
9

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; }
}
ddyer
fuente
No apto para foreach bucles.
John McClane
8

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**/);
Igor Rybak
fuente
1
@ Tvde1 y sigue siendo útil para otros usuarios, por lo que los nuevos métodos y soluciones siempre son bienvenidos
Andrei Suvorkov
Wow, eso es feo.
DS.
7

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?

Oleksii Kyslytsyn
fuente
6

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");
    }
}
Hitendra Solanki
fuente
2
¿Cómo usaría esto con los bucles for-each? ;)
Willi Mentzel
55
Esto no funciona si tiene una condición de bucle más sofisticada, como list.size ()> 5. También es realmente solo un truco. ¡Es difícil de leer y es una mala práctica!
Neurona
Es propenso a errores. Imagina que cambiaste el bucle interno a (int k = 0; k < 10; k++)y no arreglaste todo k = 9a k = 10. Puede entrar en un bucle infinito.
Florian F
5

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;
        }
    }
}
Bishal Jaiswal
fuente
4
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;
    }
}
Panzercrisis
fuente
4

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;
         }
    }
}
Chit Khine
fuente
Prefiero este patrón A menudo me ha causado romper los bucles en una función separada. Mi código siempre ha sido mejor después de hacerlo, así que por esta razón me gusta mucho esta respuesta.
Bill K
4

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;
     }
}
Bansal de Keshav
fuente
44
En mi opinión, estos ejemplos de ruptura no son muy útiles, porque incluso sin la etiqueta se romperían en el mismo punto. Además, siempre es bueno tener código que en realidad se puede ejecutar, lo cual no es el caso con su código, ya que el Innerloop Nunca se puede llegar ..
Neurona
Iba a escribir lo mismo. Las etiquetas son algo inútiles en este caso.
Taslim Oseni
4

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
    }
}
usuario2875404
fuente
4

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

Rumesh Eranga Hapuarachchi
fuente
4

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];
    }
}
ursa
fuente
1
Se ha mencionado en realidad, en una respuesta obteniendo -23 votos ... stackoverflow.com/a/886980/2516301 . Hará el trabajo, pero es una práctica de programación muy mala ...
vefthym
en efecto. Sin embargo, vi ese código heredado: bucles anidados de 4 niveles con varias condiciones de ruptura. y era más legible con excepciones que con código en línea. -23 votos es principalmente una calificación emocional, pero sí, este enfoque debe usarse con cuidado.
ursa
1
Hubiera sido aún más legible si se hubiera dividido en una llamada de función separada con un centro de retorno. A menudo se mejora aún más por un pequeño refactor, por lo que tiene sentido como una función independiente (a menudo reutilizable).
Bill K
2

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);
    }
}
Vikrant Kashyap
fuente
2

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;
        }
    }
}
mtyson
fuente
2

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 .

Ravindra HV
fuente
2

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);
                }
            }
        }
    }
}
Cuenta
fuente
2

Manifestación

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

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
        }
    }
Siddharth Choudhary
fuente
1

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;
}
Dharmik Patel
fuente
1

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");
}
Harard Vardhan
fuente
1

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;
}
voidMainReturn
fuente
1
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 '.

astryk
fuente