如何打破 Java 中的嵌套循环？

问：

我有一个这样的嵌套循环结构：

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

现在我怎样才能打破这两个循环？我看过类似的问题，但没有一个特别关注 Java。我无法应用这些解决方案，因为大多数使用 goto。

我不想将内部循环放在不同的方法中。

我不想返回循环。中断时，我完成了循环块的执行。

答1:

huntsbot.com高效搞钱，一站式跟进超10+任务平台外包需求

像其他回答者一样，我肯定更喜欢将循环放在不同的方法中，此时您可以返回以完全停止迭代。该答案仅显示如何满足问题中的要求。

您可以将 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

huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

这会直接跳到循环之后。试试看！是的，标签出现在循环之前，但那是因为它标记了循环，而不是您要退出的地方。 （您也可以继续使用标签。）

答2:

打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

从技术上讲，正确的答案是标记外循环。实际上，如果您想在内部循环内的任何位置退出，那么最好将代码外部化为一个方法（如果需要，可以使用静态方法）然后调用它。

这将为可读性带来回报。

代码会变成这样：

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

有时您使用内部循环之外的几个局部变量，将它们全部传递进来会感觉很笨重。

答3:

huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

您可以在循环周围使用命名块：

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

您无需创建新块即可使用标签。

不，但它使意图更加清晰。请参阅有关已接受答案的第一条评论。

答4:

huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

我从不使用标签。进入这似乎是一种不好的做法。这是我要做的：

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

答5:

huntsbot.com高效搞钱，一站式跟进超10+任务平台外包需求

您可以使用标签：

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

答6:

HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

使用一个函数：

public void doSomething(List types, List types2){
  for(Type t1 : types){
    for (Type t : types2) {
      if (some condition) {
         // Do something and return...
         return;
      }
    }
  }
}

答7:

huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

您可以使用临时变量：

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

答8:

huntsbot.com – 高效赚钱，自由工作

如果您不喜欢 break 和 goto，您可以使用“传统”的 for 循环代替 for-in，并带有一个额外的中止条件：

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

不适合 foreach 循环。

@JohnMcClane 而且您在一个 9 岁以上的问题的许多答案上发送垃圾邮件，因为...？

答9:

huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。

当您需要退出多个循环时，单独使用“break”关键字不是合适的方法。无论您的语句被多少个循环包围，您都可以退出立即循环。您可以使用带有标签的“break”！在这里，我使用了标签“abc”您可以在 Java 中的任何函数中编写如下代码

这段代码展示了如何从最外层的循环中退出

 abc: 
    for (int i = 0; i < 10; i++) { 
        for (int j = 0; j < 10; j++) { 
           for (int k = 0; k < 10; k++) { 
              if (k == 1){
                 break abc;
              } 
        } 
    } 
}

您也可以使用 break 语句退出嵌套循环中的任何循环。

    for (int i = 0; i < 10; i++) { 
       abc:for (int j = 0; j < 10; j++) { 
           for (int k = 0; k < 10; k++) { 
              if (k == 1){
                 break abc;
              } 
        } 
    } 
}

以下代码显示了从最内层循环退出的示例。在其他作品中，执行以下代码后，您处于“k”变量循环的外部，但仍在“j”和“i”变量的循环内。

    for (int i = 0; i < 10; i++) { 
        for (int j = 0; j < 10; j++) { 
           for (int k = 0; k < 10; k++) { 
              if (k == 1){
                 break;
              } 
        } 
    } 
}

答10:

huntsbot.com – 高效赚钱，自由工作

我需要做类似的事情，但我选择不使用增强的 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;
        }
    }
}

在条件被破坏后，我不觉得迭代所有项目很酷。因此，我会在 else 情况下添加一个中断。

@boutta 我不确定你是如何得出这个结论的。一旦条件为真，两个循环都将退出。

好的，我没有得到操纵 's' var 的部分。但我发现那种不好的风格，因为 s 代表大小。然后我更喜欢带有显式变量的 ddyer 的答案：stackoverflow.com/a/25124317/15108

@boutta 您可以将 s 更改为小于 i 的值或将 i 更改为大于或等于 s 的值，两者都应该可以解决问题。您更改 s 是对的，因为它可以在以后在其他地方使用，但更改 i 不会造成伤害，只会确保第一个 for 不会继续循环。

答11:

huntsbot.com – 高效赚钱，自由工作

我更喜欢在循环测试中添加一个明确的“退出”。它使任何不经意的读者都清楚循环可能会提前终止。

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

原文链接：https://www.huntsbot.com/qa/KJP7/how-do-i-break-out-of-nested-loops-in-java?lang=zh_CN&from=csdn

打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!