blocks|key|260706|text|不，这不是一种糟糕的做法。这是最简单、最有效的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|260707|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

No, it is not a bad practice. It is the most easiest and efficient way.

blocks|key|260751|text|在循环中使用break可以是完全合法的，甚至是解决某些问题的唯一方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|260752|然而，它的坏名声来自于这样一个事实，即新的程序员通常滥用它，导致代码混乱，特别是通过使用break在条件中停止循环，而这些条件本来可以在loop条件语句中编写。|260753|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Using break in loops can be perfectly legitimate and it can even be the only way to solve some problems.

However, it's bad reputation comes from the fact that new programmers usually abuse it, leading to confusing code, especially by using break to stop the loop in conditions that could have been written in the loop condition statement in the first place.

blocks|key|44088|text|虽然使用break是一种不错的做法，而且有很多很好的用法，但它不应该是您所依赖的全部。几乎任何对break的使用都可以写入循环条件。当使用真实条件时，代码的可读性要好得多，但在长时间运行或无限循环的情况下，中断非常有意义。如上所示，它们在搜索数据时也很有意义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|44089|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

While its not bad practice to use break and there are many excellent uses for it, it should not be all you rely upon. Almost any use of a break can be written into the loop condition. Code is far more readable when real conditions are used, but in the case of a long-running or infinite loop, breaks make perfect sense. They also make sense when searching for data, as shown above.

blocks|key|260820|text|如果事先知道循环必须在哪里结束，那么在for、while或`do-while循环中声明条件可能会提高代码的可读性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|260821|否则，这就是break的用例。|260822|entityMap^0|J|3|N|5|T|9|0|6|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

If you know in advance where the loop will have to stop, it will probably improve code readability to state the condition in the <code>for</code>, <code>while</code>, or <code>`do-while</code> loop.

Otherwise, that's the exact use case for <code>break</code>.

blocks|key|44154|text|这不是一种糟糕的做法，但它会降低代码的可读性。解决这个问题的一个有用的重构方法是将循环移动到一个单独的方法，然后使用return语句而不是break语句，例如这样(从@Chris的答案中提取的示例)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|44155|String+item;

for(int+x+=+0;+x+<+10;+x%2B%2B)
{
++++//+Linear+search.
++++if(array[x].equals("Item+I+am+looking+for"))
++++{
++++++++//you've+found+the+item.+Let's+stop.
++++++++item+=+array[x];
++++++++break;+
++++}
}|code-block|syntax|javascript|44156|可以(使用extract+method)重构为以下内容：|offset|length|44157|public+String+searchForItem(String+itemIamLookingFor)
{
++++for(int+x+=+0;+x+<+10;+x%2B%2B)
++++{
++++++++if(array[x].equals(itemIamLookingFor))
++++++++{
++++++++++++return+array[x];
++++++++}
++++}
}|44158|当从周围的代码中调用它时，可以证明它更具可读性。|44159|entityMap|0|LINK|mutability|MUTABLE|url|http://refactoring.com/catalog/extractMethod.html^0|0|0|5|E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|K|3|L|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

It isn't bad practice, but it can make code less readable. One useful refactoring to work around this is to move the loop to a separate method, and then use a return statement instead of a break, for example this (example lifted from @Chris's answer):

<pre><code>String item;

for(int x = 0; x &lt; 10; x++)
{
 // Linear search.
 if(array[x].equals("Item I am looking for"))
 {
 //you've found the item. Let's stop.
 item = array[x];
 break; 
 }
}
</code></pre>

can be refactored (using <a href="http://refactoring.com/catalog/extractMethod.html" rel="nofollow">extract method</a>) to this:

<pre><code>public String searchForItem(String itemIamLookingFor)
{
 for(int x = 0; x &lt; 10; x++)
 {
 if(array[x].equals(itemIamLookingFor))
 {
 return array[x];
 }
 }
}
</code></pre>

Which when called from the surrounding code can prove to be more readable.

blocks|key|44176|text|break和continue破坏了读者的可读性，尽管它通常很有用。与其说是"goto“概念，不如说是差不多。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|44177|此外，如果你使用一些新的语言，如Scala+(灵感来自Java和函数编程语言，如Ocaml)，你会注意到break和continue已经消失了。|44178|特别是在函数式编程中，这种代码风格被避免了：|44179|Why+scala+doesn't+support+break+and+continue?|44180|总而言之：break和continue在Java语言中被广泛用于命令式风格，但对于任何曾经练习函数式编程的程序员来说，它可能是..真奇怪。|44181|entityMap|0|LINK|mutability|MUTABLE|url|http://books.google.fr/books?id=MFjNhTjeQKkC&pg=PA131&lpg=PA131&dq=break%2520continue%2520scala&source=bl&ots=FLskVFHQrn&sig=5BH-KXJ2Fd7P20b7QZ1MlSPJI9o&hl=en&sa=X&ei=fuUIUqyPF4HE7Aah74DIDA&redir_esc=y#v=onepage&q=break%2520continue%2520scala&f=false^0|0|5|6|8|0|1G|5|1M|8|0|0|0|19|0|0|5|5|B|8|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|L|3|M|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]]]

<code>break</code> and <code>continue</code> breaks the readability for the reader, although it's often useful.
Not as much as "goto" concept, but almost.

Besides, if you take some new languages like Scala (inspired by Java and functional programming languages like Ocaml), you will notice that <code>break</code> and <code>continue</code> simply disappeared.

Especially in functional programming, this style of code is avoided:

<a href="http://books.google.fr/books?id=MFjNhTjeQKkC&amp;pg=PA131&amp;lpg=PA131&amp;dq=break%20continue%20scala&amp;source=bl&amp;ots=FLskVFHQrn&amp;sig=5BH-KXJ2Fd7P20b7QZ1MlSPJI9o&amp;hl=en&amp;sa=X&amp;ei=fuUIUqyPF4HE7Aah74DIDA&amp;redir_esc=y#v=onepage&amp;q=break%20continue%20scala&amp;f=false" rel="nofollow">Why scala doesn't support break and continue?</a>

To sum up: <code>break</code> and <code>continue</code>are widely used in Java for an imperative style, but for any coders that used to practice functional programming, it might be.. weird.

blocks|key|44207|text|如果你开始做这样的事情，那么我会说它开始变得有点奇怪，你最好把它移到一个单独的方法，在matchedCondition上returns一个结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|44208|boolean+matched+=+false;
for(int+i+=+0;+i+<+10;+i%2B%2B)+{
++++for(int+j+=+0;+j+<+10;+j%2B%2B)+{
++++++++if(matchedCondition)+{
++++++++++++matched+=+true;
++++++++++++break;
++++++++}
++++}
++++if(matched)+{
++++++++break;
++++}
}|code-block|syntax|javascript|44209|要详细说明如何清理上面的代码，您可以重构，将代码移动到一个returns函数，而不是使用breaks。一般来说，这可以更好地处理复杂/混乱的breaks。|44210|public+boolean++matches()
++++for(int+i+=+0;+i+<+10;+i%2B%2B)+{
++++++++for(int+j+=+0;+j+<+10;+j%2B%2B)+{
++++++++++++if(matchedCondition)+{
++++++++++++++++return+true;
++++++++++++}
++++++++}
++++}
++++return+false;
}|44211|然而，对于像我下面的例子这样简单的东西。一定要使用break！|44212|for(int+i+=+0;+i+<+10;+i%2B%2B)+{
++++if(wereDoneHere())+{+//+we're+done,+break.
++++++++break;
++++}
}|44213|更改条件，在上面的例子中是i，以及j的值，你只会让代码变得很难读。还有一种情况是，上限(在例子中是10)是变量，所以很难猜测为了退出循环应该将它设置为什么值。当然，你可以只将i和j设置为Integer.MAX_VALUE，但我认为你可以看到这很快就开始变得混乱了。:)|44214|entityMap^0|1O|7|0|0|T|7|18|6|1Y|6|0|0|P|5|0|0|D|1|H|1|2F|1|2H|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|V|$]]

If you start to do something like this, then I would say it starts to get a bit strange and you're better off moving it to a seperate method that <code>returns</code> a result upon the matchedCondition.

<pre><code>boolean matched = false;
for(int i = 0; i &lt; 10; i++) {
 for(int j = 0; j &lt; 10; j++) {
 if(matchedCondition) {
 matched = true;
 break;
 }
 }
 if(matched) {
 break;
 }
}
</code></pre>

To elaborate on how to clean up the above code, you can refactor, moving the code to a function that <code>returns</code> instead of using <code>breaks</code>. This is in general, better dealing with complex/messy <code>breaks</code>.

<pre><code>public boolean matches()
 for(int i = 0; i &lt; 10; i++) {
 for(int j = 0; j &lt; 10; j++) {
 if(matchedCondition) {
 return true;
 }
 }
 }
 return false;
}
</code></pre>

However for something simple like my below example. By all means use <code>break</code>!

<pre><code>for(int i = 0; i &lt; 10; i++) {
 if(wereDoneHere()) { // we're done, break.
 break;
 }
}
</code></pre>

And changing the conditions, in the above case <code>i</code>, and <code>j</code>'s value, you would just make the code really hard to read. Also there could be a case where the upper limits (10 in the example) are variables so then it would be even harder to guess what value to set it to in order to exit the loop. You could of course just set <code>i</code> and <code>j</code> to Integer.MAX_VALUE, but I think you can see this starts to get messy very quickly. :)

blocks|key|260984|text|在我看来，当要完成固定数量的迭代时，应该使用For循环，并且它们不会在每次迭代完成之前停止。在另一种情况下，如果您想要提前退出，我更喜欢使用While循环。即使你读了这两个字，它看起来也更符合逻辑。下面是一些例子：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|260985|for+(int+i=0;i<10;i%2B%2B)+{
++++System.out.println(i);
}|code-block|syntax|javascript|260986|当我快速阅读这段代码时，我将确定它将打印出10行，然后继续。|260987|for+(int+i=0;i<10;i%2B%2B)+{
++++if+(someCondition)+break;
++++System.out.println(i);
}|260988|这一点我已经不太清楚了。为什么你会先声明你将进行10次迭代，然后在循环中添加一些额外的条件来更快地停止？|260989|我更喜欢以这种方式编写的前一个示例(即使它有点冗长，但这只是多了一行)：|260990|int+i=0;
while+(i<10+&&+!someCondition)+{
++++System.out.println(i);
++++i%2B%2B;
}|260991|阅读这段代码的每个人都会立即看到，有一个额外的条件可能会提前终止循环。|260992|当然，在非常小的循环中，您总是可以讨论每个程序员都会注意到break语句。但我可以从我自己的经验中看出，在更大的循环中，这些中断是可以被监督的。(这将我们带到另一个主题，开始将代码拆分成更小的块)|260993|entityMap^0|M|3|1Y|5|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|19|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1B|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1C|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|Z|$]]

In my opinion a <code>For</code> loop should be used when a fixed amount of iterations will be done and they won't be stopped before every iteration has been completed. In the other case where you want to quit earlier I prefer to use a <code>While</code> loop. Even if you read those two little words it seems more logical. Some examples:

<pre><code>for (int i=0;i&lt;10;i++) {
 System.out.println(i);
}
</code></pre>

When I read this code quickly I will know for sure it will print out 10 lines and then go on.

<pre><code>for (int i=0;i&lt;10;i++) {
 if (someCondition) break;
 System.out.println(i);
}
</code></pre>

This one is already less clear to me. Why would you first state you will take 10 iterations, but then inside the loop add some extra conditions to stop sooner?

I prefer the previous example written in this way (even when it's a little more verbose, but that's only with 1 line more):

<pre><code>int i=0;
while (i&lt;10 &amp;&amp; !someCondition) {
 System.out.println(i);
 i++;
}
</code></pre>

Everyone who will read this code will see immediatly that there is an extra condition that might terminate the loop earlier.

Ofcourse in very small loops you can always discuss that every programmer will notice the break statement. But I can tell from my own experience that in larger loops those breaks can be overseen. (And that brings us to another topic to start splitting up code in smaller chunks)

blocks|key|44289|text|在许多常见的情况下，break是表达算法的最自然的方式。它们被称为“循环半”结构；范例示例如下|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|44290|while+(true)+{
++++item+=+stream.next();
++++if+(item+==+EOF)
++++++++break;
++++process(item);
}|code-block|syntax|javascript|44291|如果你不能使用break来做这件事，你必须重复你自己：|44292|item+=+stream.next();
while+(item+!=+EOF)+{
++++process(item);
++++item+=+stream.next();
}|44293|It+is+generally+agreed+that+this+is+worse.|44294|类似地，对于continue，有一个常见的模式，如下所示：|44295|for+(item+in+list)+{
++++if+(ignore_p(item))
++++++++continue;
++++if+(trivial_p(item))+{
++++++++process_trivial(item);
++++++++continue;
++++}
++++process_complicated(item);
}|44296|这通常比使用链式else+if的替代方法更具可读性，特别是当process_complicated不仅仅是一个函数调用时。|44297|进一步阅读：Loop+Exits+and+Structured+Programming:+Reopening+the+Debate|44298|entityMap|0|LINK|mutability|MUTABLE|url|http://c2.com/cgi/wiki?DontRepeatYourself|1|http://www-cs.stanford.edu/~eroberts/papers/SIGCSE-1995/LoopExits.pdf^0|A|5|0|0|7|5|0|0|0|16|0|0|6|8|0|0|8|7|U|J|0|6|1N|1|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|Q|3|R|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|1N|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1T|8|@]|D|@$9|1U|A|1V|1|1W]]|E|$]]|$1|Y|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]|16|$5|11|12|13|E|$14|17]]]]

There are a number of common situations for which <code>break</code> is the most natural way to express the algorithm. They are called "loop-and-a-half" constructs; the paradigm example is

<pre><code>while (true) {
 item = stream.next();
 if (item == EOF)
 break;
 process(item);
}
</code></pre>

If you can't use <code>break</code> for this you have to repeat yourself instead:

<pre><code>item = stream.next();
while (item != EOF) {
 process(item);
 item = stream.next();
}
</code></pre>

<a href="http://c2.com/cgi/wiki?DontRepeatYourself" rel="nofollow">It is generally agreed that this is worse.</a>

Similarly, for <code>continue</code>, there is a common pattern that looks like this:

<pre><code>for (item in list) {
 if (ignore_p(item))
 continue;
 if (trivial_p(item)) {
 process_trivial(item);
 continue;
 }
 process_complicated(item);
}
</code></pre>

This is often more readable than the alternative with chained <code>else if</code>, particularly when <code>process_complicated</code> is more than just one function call.

Further reading: <a href="http://www-cs.stanford.edu/~eroberts/papers/SIGCSE-1995/LoopExits.pdf" rel="nofollow">Loop Exits and Structured Programming:
Reopening the Debate</a>

I was wondering if it is a "bad practice" to use a <code>break</code> statement to exit a loop instead of fulfilling the loop condition?

I do not have enough insight in Java and the JVM to know how a loop is handled, so I was wondering if I was overlooking something critical by doing so.

The focus of this question: is there a specific performance overhead?

Is it bad practice to use break to exit a loop in Java?

Java

我想知道使用break语句退出循环而不是满足循环条件是不是一种“糟糕的做法”？我对Java和JVM没有足够的洞察力，无法知道循环是如何处理的，所以我想知道这样做是否忽略了一些关键的东西。这个问题的焦点是:是否存在特定的性能开销？

问在Java中使用break退出循环是不是一种糟糕的做法？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中使用break退出循环是不是一种糟糕的做法？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中使用break退出循环是不是一种糟糕的做法？
EN