Java에서 중첩 루프를 제거하려면 어떻게해야합니까?

다음과 같이 중첩 루프 구조가 있습니다.

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

이제 두 루프에서 어떻게 벗어날 수 있습니까? 비슷한 질문을 보았지만 Java와 관련된 것은 없습니다. 대부분의 gotos를 사용했기 때문에 이러한 솔루션을 적용 할 수 없습니다.

내부 루프를 다른 방법으로 넣고 싶지 않습니다.

루프를 다시 실행하고 싶지 않습니다. 깨면 루프 블록 실행이 끝났습니다.

다른 응답자와 마찬가지로 루프를 다른 방법으로 넣는 것을 선호 합니다.이 시점에서 완전히 반복을 중지하기 위해 돌아갈 수 있습니다. 이 답변은 질문의 요구 사항을 어떻게 충족시킬 수 있는지 보여줍니다.

break외부 루프의 레이블과 함께 사용할 수 있습니다 . 예를 들면 다음과 같습니다.

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

인쇄합니다 :

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

기술적으로 정답은 외부 루프에 레이블을 지정하는 것입니다. 실제로 내부 루프 내부의 어느 지점에서나 종료하려면 코드를 메소드 (필요한 경우 정적 메소드)로 외부화 한 다음 호출하는 것이 좋습니다.

가독성에 대한 보상입니다.

코드는 다음과 같습니다.

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

허용되는 답변의 예와 일치 :

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

루프 주위에 명명 된 블록을 사용할 수 있습니다.

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

나는 라벨을 사용하지 않습니다. 들어가는 것은 나쁜 습관처럼 보입니다. 내가 할 일은 다음과 같습니다.

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

라벨을 사용할 수 있습니다 :

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

기능을 사용하십시오 :

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

임시 변수를 사용할 수 있습니다 :

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

함수에 따라 내부 루프를 종료 / 복귀 할 수도 있습니다.

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

breaks 및 gotos 가 마음에 들지 않으면 추가 중단 조건과 함께 for-in 대신 "전통적인"for 루프를 사용할 수 있습니다.

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

비슷한 작업을 수행해야했지만 Enhanced for 루프를 사용하지 않기로 선택했습니다.

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

루프 테스트에 명시적인 "종료"를 추가하는 것을 선호합니다. 루프를 조기에 종료 할 수 있다는 것은 모든 일반 독자에게 분명합니다.

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

자바 8 Stream솔루션 :

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

일반적으로 그러한 경우에는 더 의미있는 논리의 범위에 들어갑니다. 문제가있는 반복되는 'for'객체 중 일부를 검색하거나 조작한다고 가정 해 보겠습니다.

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

주요 단점 :

• 대략 두 배 더 많은 라인
• 더 많은 컴퓨팅 사이클 소비, 즉 알고리즘 관점에서 느리다는 의미
• 더 많은 타이핑 작업

장점 :

• 기능 세분성으로 인해 우려 분리 비율이 높음
• 검색 / 조작 로직의 높은 재 사용률 및 제어 비율
• 방법이 길지 않기 때문에 더 작고 이해하기 쉽습니다.
• 높은 가독성

따라서 다른 접근 방식을 통해 사례를 처리하고 있습니다.

기본적 으로이 질문의 저자에게 질문 :이 접근법에 대해 어떻게 생각하십니까?

label : 및 flags를 사용하지 않고 모든 루프에서 벗어날 수 있습니다.

까다로운 해결책입니다.

여기서 condition1은 루프 K와 J를 끊는 데 사용되는 조건이고 condition2는 루프 K, J와 I를 끊는 데 사용되는 조건입니다.

예를 들면 다음과 같습니다.

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

Labeled Break 개념은 Java에서 중첩 루프를 분리하는 데 사용됩니다. Labeled Break 를 사용하면 어느 위치에서나 루프 중첩을 중단 할 수 있습니다. 예 1 :

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

루프가 3 개 있고 루프 3을 종료한다고 가정합니다. 예 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;
    }
}

그것이 어떤 함수 안에 있다면 왜 그것을 반환하지 않습니까?

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

가장 쉽고 쉬운 방법

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

오히려 비정상적인 접근법이지만 코드 길이 ( 성능 아님) 측면에서 이것은 가장 쉬운 방법입니다.

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

라벨을 사용하십시오.

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

이 기사를 참조 하십시오

예제없이 언급 된 또 하나의 솔루션 (실제로 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.
}

물론 BreakLoopException내부, 개인 및 스택 없음 추적으로 가속화되어야합니다.

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

for (int j = 0; j < 5; j++) //inner loop로 교체해야합니다 for (int j = 0; j < 5 && !exitloops; j++).

여기서이 경우 condition이 인 경우 완전한 중첩 루프를 종료해야합니다 True. 그러나 우리 exitloops가 상단에만 사용하면 loop

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

그러면 내부 루프가 종료되도록 알리는 추가 플래그가 없기 때문에 내부 루프가 계속됩니다.

예 : if i = 3와 j=2then 조건은 false입니다. 그러나 내부 루프의 다음 반복에서 j=3 다음 조건이 (i*j)될 수 9있는 true있지만까지 내부 루프가 계속됩니다 j된다 5.

따라서 exitloops내부 루프에도 사용해야 합니다.

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 INFORMATION 제안과 같이 내부 루프를 끊는 조건을 외부 루프의 조건으로 사용하십시오.

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

새로운 구현이라면 로직을 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
    }
}

그렇지 않으면 특수 조건이 발생할 때 플래그를 설정하고 각 루프 조건에서 해당 플래그를 확인할 수 있습니다.

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

여기! 따라서 간단한 휴식은 작동하지 않지만을 사용하여 작동하도록 만들 수 있습니다 continue.

단순히 하나의 프로그래밍 언어에서 Java로 로직을 포팅하고 작동하는 것을 원한다면 레이블을 사용해보십시오 .

데모에 대한 break, continue그리고 label:

Java 키워드 break및 continue기본값이 있습니다. 그것은 "가장 가까운 루프"이며, 오늘날 몇 년 동안 Java를 사용한 후 방금 찾았습니다!

드물게 사용되지만 유용합니다.

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

데모

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

다음을 수행 할 수 있습니다.

1. 지역 변수를 false

2. true깨고 싶을 때 첫 번째 루프에서 해당 변수 를 설정하십시오.

3. 그런 다음 외부 루프에서 조건이 설정되어 있는지 여부를 확인한 다음 외부 루프에서도 분리 할 수 ​​있습니다.

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

어떤 경우에는 while루프를 효과적으로 사용할 수 있습니다.

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 ++에있는 것처럼 goto 기능이 없습니다. 그러나 여전히 gotoJava에서 예약 된 키워드입니다. 그들은 미래에 그것을 구현할 수 있습니다. 귀하의 질문에 대한 대답은 Java에 레이블이라는 것이 있고 continueand 및 break문을 적용 할 수 있다는 것 입니다. 아래 코드를 찾으십시오.

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

외부 루프에 대한 플래그를 작성하고 내부 루프를 실행할 때마다 답이 될 수 있는지 확인하십시오.

이처럼 :

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처리가 완료되면 플래그로 사용하십시오 . 그런 다음 내부 루프는 조건이 충족되지 않은 동안에 만 계속 작동합니다. 어느 쪽이든, 외부 루프는 계속 작동합니다.