Java'da iç içe döngülerden nasıl çıkabilirim?

Böyle bir iç içe döngü yapı var:

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

Şimdi her iki devreden nasıl ayrılabilirim? Benzer sorulara baktım, ancak hiçbiri özellikle Java ile ilgili değil. Bu çözümleri uygulayamadım çünkü en çok kullanılan gotolar.

İç döngüyü farklı bir yönteme koymak istemiyorum.

Döngülerý tekrar çalmak istemiyorum. Kırılırken döngü bloğunun yürütülmesi bitti.

Diğer cevaplayıcılar gibi, döngüleri kesinlikle farklı bir yönteme koymayı tercih ederim , bu noktada tekrarlamayı tamamen durdurmak için geri dönebilirsiniz. Bu cevap sadece sorudaki gereksinimlerin nasıl karşılanabileceğini göstermektedir.

breakDış döngü için bir etiketle kullanabilirsiniz . Örneğin:

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

Bu yazdırır:

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

Teknik olarak doğru cevap dış halkayı etiketlemektir. Uygulamada, bir iç döngü içinde herhangi bir noktada çıkmak istiyorsanız, kodu bir yönteme (gerekirse statik bir yöntem) dışsallaştırıp daha sonra çağırmanız daha iyi olur.

Bu okunabilirlik için yararlı olacaktır.

Kod şöyle bir şey olur:

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

Kabul edilen cevap için örnek eşleme:

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

Döngülerin çevresinde adlandırılmış bir blok kullanabilirsiniz:

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

Asla etiket kullanmam. İçeri girmek kötü bir uygulama gibi görünüyor. İşte yapacağım şey:

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

Etiketleri kullanabilirsiniz:

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

Bir işlev kullanı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;
      }
    }
  }
}

Geçici bir değişken kullanabilirsiniz:

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

İşlevinize bağlı olarak, iç döngüden de çıkıp geri dönebilirsiniz:

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

Eğer breaks ve gotos'den hoşlanmıyorsanız , ekstra iptal koşuluyla for-in yerine "geleneksel" bir döngü kullanabilirsiniz:

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

Benzer bir şey yapmam gerekiyordu, ama bunu yapmak için gelişmiş döngüyü kullanmamayı seçtim.

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

Döngü testlerine açık bir "çıkış" eklemeyi tercih ederim. Herhangi bir sıradan okuyucu için, döngünün erken sonlanabileceğini açıkça belirtir.

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

Java 8 Streamçözümü:

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

Genellikle bu gibi durumlarda, daha anlamlı bir mantık kapsamına girer, diyelim ki söz konusu yinelenen 'for'-nesnelerin bazıları üzerinde bazı aramalar veya manipülasyonlar, bu yüzden genellikle fonksiyonel yaklaşımı kullanıyorum:

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

Büyük eksileri:

• kabaca iki satır daha
• daha fazla bilgi işlem çevrimi tüketimi, yani algoritmik bakış açısından daha yavaştır
• daha fazla yazım işi

Profesyoneller:

• fonksiyonel taneciklik nedeniyle endişelerin ayrılmasına daha yüksek oran
• daha yüksek yeniden kullanılabilirlik oranı ve mantıksız arama / manipülasyon kontrolü
• yöntemler uzun değildir, bu nedenle daha kompakt ve anlaşılması daha kolaydır
• daha yüksek okunabilirlik oranı

Yani sadece davayı farklı bir yaklaşımla ele alıyor.

Temel olarak bu sorunun yazarına bir soru: bu yaklaşım hakkında ne düşünüyorsunuz?

Herhangi bir etiket: ve bayrak kullanmadan tüm döngülerden kopabilirsiniz.

Bu sadece zor bir çözüm.

Burada koşul1, döngü K ve J'den kopmak için kullanılan durumdur. Koşul2, döngü K, J ve I'den kopmak için kullanılan durumdur.

Örneğin:

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

Etiketli mola kavramı java'da iç içe döngüler oluşturmak için kullanılır, etiketli mola kullanarak ilmeklerin herhangi bir konumda iç içe geçmesini engelleyebilirsiniz. Örnek 1:

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

3 döngü olduğunu ve döngüyü sonlandırmak istediğinizi varsayalım: Örnek 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;
    }
}

Eğer bir işlevin içindeyse, neden geri vermiyorsunuz:

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

En İyi ve Kolay Yöntem ..

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

Oldukça sıradışı bir yaklaşım ama kod uzunluğu ( performans değil ) açısından bu yapabileceğiniz en kolay şey:

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

Etiketleri Kullan.

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

Bakın bu makalede

Örnek olmadan bahsedilen başka bir çözüm (aslında prod kodunda çalışır).

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

Tabii ki BreakLoopExceptiondahili, özel ve yığınsız iz ile hızlandırılmış olmalıdır:

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

for (int j = 0; j < 5; j++) //inner loopile değiştirilmelidir for (int j = 0; j < 5 && !exitloops; j++).

Burada, bu durumda koşul varsa, tam iç içe döngüler çıkarılmalıdır True. Ama exitloopssadece üst tarafa kullanırsakloop

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

Daha sonra iç döngü devam edecektir, çünkü bu iç döngüyü çıkışa bildiren ekstra bir bayrak yoktur.

Örnek: if i = 3ve j=2then koşulu false. Ancak iç döngü bir sonraki yinelemesinde, j=3 koşul olan (i*j)haline 9gelir, trueancak iç döngü jhaline gelene kadar devam eder 5.

Bu nedenle, exitloopsiç döngülere de kullanması gerekir .

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

@ 1800 BİLGİ önerisi gibi, iç halkayı dış halkanın koşulu olarak kıran koşulu kullanın:

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

Bu yeni bir uygulama ise, mantığı if-else_if-else ifadeleri olarak yeniden yazmayı deneyebilirsiniz.

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

Aksi takdirde, bu özel koşul oluştuğunda bir bayrak ayarlamayı deneyebilir ve döngü koşullarınızın her birinde o bayrağı kontrol edebilirsiniz.

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

BURAYA! Yani, basit bir mola işe yaramazken, çalışmak için yapılabilir continue.

Eğer mantığı tek bir programlama dilinden Java'ya taşıyorsanız ve sadece işe yarayan şeyleri almak istiyorsanız etiketleri kullanmayı deneyebilirsiniz .

Demo için break, continueve label:

Java anahtar kelimeleri breakve continuevarsayılan bir değere sahip. Bu "en yakın döngü" ve bugün, Java'yı kullandıktan birkaç yıl sonra, anladım!

Nadir kullanılmış gibi görünüyor, ancak kullanışlı.

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

gösteri

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

Aşağıdakileri yapabilirsiniz:

1. için yerel bir değişken belirleyin false

2. truekırmak istediğinizde bu değişkeni ilk döngüde ayarlayın

3. dış döngüde, koşulun ayarlanıp ayarlanmadığını ve ardından dış döngüden kopup kopmadığını kontrol edebilirsiniz.

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

Bazı durumlarda, whiledöngüyü burada etkili bir şekilde kullanabiliriz .

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, C ++ 'da olduğu gibi bir goto özelliğine sahip değildir. Ama yine de, gotoJava'da ayrılmış bir anahtar kelime. Gelecekte uygulayabilirler. Sorunuz için, Java'da etiket continueve breakifadesini uygulayabileceğiniz bir etiket var . Aşağıdaki kodu bulun:

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

Hatta dış döngü için bir bayrak oluşturmak ve her iç döngüden sonra cevap olabileceğini kontrol etmek.

Bunun gibi:

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

conditionİşlemeyi bitirdiğinizde bayrak olarak kullanın . Daha sonra iç döngü sadece koşul karşılanmadığında devam eder. Her iki durumda da, dış döngü chuggin üzerinde kalacak '.