我听说一些“休息”并不是坏习惯。这个呢？

Question

我经常听说在 Java 中使用 break 被认为是不好的做法，但在阅读了 Stack Overflow 上的一些帖子后，我发现情况并非如此。许多人说在某些情况下这是可以接受的。

在这种情况下，我有点困惑什么是/不是不好的做法。

对于 Project Euler：问题 7，我构建了下面的代码。挑战是找到第 10001 个素数。

int index = 2, count = 1, numPrime = 1;

while (true) {
    index++;

    if (isPrime(index)) {
        count = index;
        numPrime++;
    }

    if (numPrime >= 10001)
        break;
}

System.out.println(count);

这会返回正确的答案（21 毫秒内），但我是否忽略了一个严重的警告？创建一个没有中断的 while 循环是 100% 可能的，但我发现这更容易理解。

我使用 break; 的方式是不好的做法吗？我知道总有办法使用它，但它真的有那么糟糕吗？

非常感谢

Justian

编辑

这是我的 isPrime() 代码。当我这样做的时候，我不妨优化一下。

public static boolean isPrime(long num) {  
    if (num == 2)
        return true;

    if (num % 2 == 0 || num <= 0)
        return false;

    for (long i = 3; i * i <= num; i += 2)
        if (num % i == 0)
            return false;

    return true;
}

Answer 1

在这种情况下，在我看来，更改 while 条件会更容易：

while (numPrime < 10001) {

结束时，通常就是这种情况。

if (condition)
{
    break;
}

当 while(true) 循环以... 尽管您需要检查循环体中的其他内容是否执行继续。

或者，您可以稍微重组它：

int current = 1;
for (int i = 0; i < 10001; i++)
{
    current++;
    while (!isPrime(current))
    {
        current++;
    }
}

然后 current 将是最后的答案。

当您尝试执行特定次数的某件事时，我通常更喜欢 for 循环而不是 while 循环。在这种情况下，“某事”是“找到下一个素数”。

我觉得编程中的一些教条太过分了——包括“方法的一个出口点”和“不要使用break”。尽可能编写可读性强的代码。如果您查看某些代码并感觉其中发生的情况并不那么明显，请尝试找出其他构造它的方法。有时这是改变循环的情况；有时是提取方法；有时它会反转一些逻辑（首先处理负分支，可能提前退出，然后处理正常情况）。

Answer 2

如果你可以不休息地离开，那就去做吧。

做

 while (numPrime < 10001) ...

Answer 3

有几个条件才需要使用中断。一种是当您需要执行 N.5 个循环时——即，您将执行循环多次，但最后一次总是在循环体中间的某个位置执行。在这种情况下，您可以避免使用中断，但这样做通常会混淆代码或导致重复。例如：

while (true) {
    first part;
    if (finished) 
       break;
    second part;
}

可以变成类似：

first part;
while (!finished) {
    second part;
    first part;
}

或：

while (!finished) {
    first part;
    if (!finished)
        second part;
}

这些都不一定是重大改进。中断有意义的另一种情况是简单地处理错误之类的事情。例如，如果您已传递 N 个文件来处理，那么如果其中一个文件无法打开，则退出循环可能是有意义的。尽管如此，当它完全合理时，显然最好在循环条件中明确声明退出循环的条件。

Answer 4

这就是 do/while 的发明目的：

do {
//...
} while(numPrime < 10001);

我发现 while(true) 位是不好的做法，这当然会导致 break。

Answer 5

与之前所说的没有太大不同，但从可读性、透明逻辑的角度来看，我建议

long i,primes=0;
for (i=2;primes<10001;i++) {
    if (isPrime(i))
        primes++;
}

i 是答案。

Answer 6

如果只有一种条件可以退出循环，并且在检查条件之前不需要运行大量代码，并且在检查条件之后不需要运行大量代码，将条件放入循环中。

我确实认为“do{}while(1);”肯定有用途。环形。其中：

1. 在循环继续的情况下，主要条件需要在检查之前和之后都有足够的代码运行，将代码放入条件本身充其量是很尴尬的。
2. 该循环具有多个退出条件，并且逻辑上最可能位于循环顶部或底部的退出条件将需要执行特殊代码，而这些代码不应针对其他退出条件执行。

有些人喜欢使用标志来区分退出条件。我倾向于将此类标志视为避免使用实际上最能体现程序操作的编码结构的努力。

如果不太关心速度，可以避免使用任何形式的 goto、过早退出 return，或者为此使用多个 while--并且有一个简单的条件。只需将整个程序编写为状态机：

void do_whatever(void)
{
  int current_state=1;
  do
  {
    next_state = 0;
    if (current_state == 1)
    {
      do_some_stuff();
      next_state = 2;
    }
    if (current_state == 2)
    {
      do_some_more_stuff();
      next_state = 3;
    }
    ...
    current_state = next_state;
  } while(current_state);
}

有时这样的编码很有用（特别是如果“while”可以从 do_whatever() 例程中拉出到一个循环中，该循环“同时”运行多个类似编码的例程）。而且从来没有必要使用“goto”之类的东西。但就可读性而言，结构化编程结构要好得多。

在我看来，使用标志退出循环，然后根据退出原因选择几段代码之一来执行，就是用非结构化代码替换结构化代码。如果在循环中我编写，

  if (index >= numItems)
  {
    createNewItem(index);
    break;
  }

则立即（并且本地）清楚地表明我创建新项目的原因是因为我的索引超出了项目数量，并且我不需要多余地测试条件。相反，如果我循环直到找到某些东西或用完所有项目，那么我要么必须在循环后冗余地测试条件，要么向每个循环迭代添加标志测试。

Answer 7

正如其他人所指出的，您给出的示例是一个糟糕的示例，因为您可以轻松地将测试移至 WHILE 中。

我使用中断的情况是当我有一个循环时，我必须在知道这是最后一次之前进行一些处理。例如：

while (true)
{
  String inLine=inStream.readLine();
  if (inLine.startsWith("End"))
    break;
  ... process line ...
}

这个例子只是稍微做作：我经常遇到这样的问题：从文件或其他源读取一些数据，以某种方式解析这些数据，然后才知道我已经到达了我感兴趣的内容的末尾现在正在处理。

当然，您可以编写一个函数来读取该行并进行必要的解析，例如：

while (!endOfInterestingData(inStream))
{
  ... process ...
}

但是您可能会遇到这样的问题：函数和循环体都需要访问读取的数据，并且函数必须返回一个布尔值来控制循环处理，因此它无法返回数据，因此使数据可用于循环体的唯一方法是让函数将其扔到某个可相互访问的字段中，然后该字段会掩盖循环获取其数据的位置数据来自.

Answer 8

这个解决方案非常快：

#include <stdio.h>

unsigned long isqrt(unsigned long n) {
    // http://snippets.dzone.com/posts/show/2715
    unsigned long a;
    for (a = 0; n >= (2*a)+1; n -= (2*a++) + 1);
    return a;
}

void nPrimes(const long N, long *const primes)
{
    unsigned long n, count, i, root;

    primes[0] = 2;
    count = 1;

    for (n = 3; count < N; n+=2) {

        root = isqrt(n);

        for (i = 0; primes[i] <= root; i++) {
            if ((n % primes[i]) == 0) goto notPrime;
        }
/*      printf("Prime #%lu is: %lu\n", count+1, n);*/
        primes[count++] = n;

        notPrime: ;
    }
}

int main (int argc, char **argv)
{
    long N;

    if (argc > 1) {
        N = atoi(argv[1]);
    } else {
        N = 10001;
    }

    long primes[N];

    nPrimes(N, primes);

    printf("Prime #%lu is: %lu\n", N, primes[N-1]);
}

注意：

• isqrt(n) 是floor(sqrt(n))。这避免了浮点运算，无论如何我们都不需要浮点运算。算法来自 http://snippets.dzone.com/posts/show/2715。
• nPrimes 保存素数列表。这允许您仅测试素数，从而消除了绝大多数昂贵的取模操作。
• 即使素数也只测试到 iqrt(n)。
• 这是一个丑陋的 goto，但 C 没有命名的 continue，并且标志变量完全是浪费时间。
• primes 数组用 2 初始化，并且只检查 3 中的奇数。消除 3 的倍数同样是可行的，但复杂性并不简单。
• 通过保留素数平方表可以消除 isqrt 调用。这几乎肯定是矫枉过正，但如果你愿意的话也可以。
• 在我的新机器上，这个过程眨眼间就可以完成。

Answer 9

我不确定一般来说休息是一种不好的做法，但我认为这是一种不好的做法。

这有点愚蠢，因为没有必要。您的 while (true) ... break 完全等同于：

while (numPrime < 10001) {
   ...
}

但不太直观。

坚持使用规范的方式来表示事物意味着读者的计算开销更少，使您的代码更容易理解，从而更容易维护并最终更加健壮。

编辑（回应评论）：你是对的，总有一种方法可以使用它，但规则（如果你想要一个）相对简单：写下最易读的内容。在您发布的情况下，这不是最具可读性的，因为我给出的替代方案是表示这一点的规范方式。在某些情况下，例如循环遍历集合直到找到匹配的特定候选者，使用 break 可能是表示此模式的最合适方式。

尝试提出关于何时使用 break 以及何时提取变量并使用条件语句的硬性规则是很困难的（我认为这是徒劳的）。通常很容易判断什么是最简单的选择，但并非总是如此。这是经验真正重要的例子之一 - 你自己阅读和编写的好/坏代码越多，你的个人好例子和坏例子库就越大，你就越容易判断什么是“最好的” “* 表示给定概念的方式是。

*当然这是主观的！