Java 继续标签已弃用？

Question

我有 2 个 for，在嵌套 for 之后，我有一些代码，如果嵌套 for 内的条件为真，我不想执行这些代码。如果我使用break，代码就会执行，所以（正如我在SCJP中学到的）我使用continue label;作为外部for。 这是 Java 的弃用用法吗？老式的？有人建议使用递归或其他方法，但对我来说这是完全正常、简单、最新且完美的方法。

here:
for (bla bla) {
   for (bla bla) {
      if (whatever) continue here;
   }
// some code I don't want to execute if whatever is true
}

谢谢

编辑：
如果我将我的问题改写为：如何在多个嵌套的 for 之间“导航”？这种方法将是“推荐”方法吗？因为这是 SCJP 书中所说的。如果不是……这是否意味着 Katherine Sierra 和 Bert Bates 是错误的？

编辑2：
为什么不鼓励使用 continue label; ？我想要 OOP 或 Java 的概念或内部工作原理的答案，可能会出现什么问题..

Answer 1

答案是：视情况而定。如果您发现自己经常使用 continue，那么这可能表明您的代码需要重构。但是，在您给出的场景中，它似乎是一个可以使用它的地方。

Answer 2

我会重构以使其更具可读性。

例子：

if (!checkWhatever()) {
    // some code I don't want to execute if whatever is true
}
boolean checkWhatever() {
    for (bla bla) {
       for (bla bla) {
          if (whatever) return false;
       }
    }
    return true;
}

Answer 3

我会说它灰心丧气。当替代品更复杂或更容易出错时（即不是改进），它仍然具有有效的用途

Answer 4

参考您的编辑 2，它总是看起来有点不确定，因为它违反了比 OO 更古老的编程正统观念： “结构化编程”。它也带有 goto 的味道，所有优秀的程序员都知道，如果他们在代码中使用了 goto，他们就需要去忏悔。

可能有人担心它可能会使编译器更难分析函数的控制流，但它是通常出于效率原因而使用的工具。例如，java.lang.String 的 Apache 实现在此函数中使用它，这至少是一种优化：

/*
 * An implementation of a String.indexOf that is supposed to perform
 * substantially better than the default algorithm if the "needle" (the
 * subString being searched for) is a constant string.
 *
 * For example, a JIT, upon encountering a call to String.indexOf(String),
 * where the needle is a constant string, may compute the values cache, md2
 * and lastChar, and change the call to the following method.
 */
@SuppressWarnings("unused")
private static int indexOf(String haystackString, String needleString,
        int cache, int md2, char lastChar) {
    char[] haystack = haystackString.value;
    int haystackOffset = haystackString.offset;
    int haystackLength = haystackString.count;
    char[] needle = needleString.value;
    int needleOffset = needleString.offset;
    int needleLength = needleString.count;
    int needleLengthMinus1 = needleLength - 1;
    int haystackEnd = haystackOffset + haystackLength;
    // Label: <----------------------------------------
    outer_loop: for (int i = haystackOffset + needleLengthMinus1; i < haystackEnd;) {
        if (lastChar == haystack[i]) {
            for (int j = 0; j < needleLengthMinus1; ++j) {
                if (needle[j + needleOffset] != haystack[i + j
                        - needleLengthMinus1]) {
                    int skip = 1;
                    if ((cache & (1 << haystack[i])) == 0) {
                        skip += j;
                    }
                    i += Math.max(md2, skip);
                    // Continue to label:  <---------------------------
                    continue outer_loop;
                }
            }
            return i - needleLengthMinus1 - haystackOffset;
        }

        if ((cache & (1 << haystack[i])) == 0) {
            i += needleLengthMinus1;
        }
        i++;
    }
    return -1;
}

Answer 5

通过将内部循环放在自己的方法中，进行重构以使其更具可读性：

for (bla bla) {   
  DoStuff();
}
void DoStuff() {
  for (bla bla) {
    if (whatever) return;
  }
  // some code to execute when whatever is false.
}

原则：如果一个方法变得足够复杂，需要对块进行标记，请考虑将该方法的一部分重构为单独的方法，这样就不需要标签。

同样，使方法具有三个循环深度也是不明智的。除非循环非常简单。即使不需要标签。通过将复杂性隐藏在其他方法中，确保最外层的流程结构（循环、if/else 或 switch）易于阅读。即使这些方法只从一个地方调用。

Answer 6

使用名为“成功”的布尔值或类似的值。
阅读和遵循流程要容易得多。 Goto 只能用于错误处理。

boolean success = true;
for(int outer = 0; (outer <= outerLimit) && sucess; outer++)
{
    for(int inner = 0; (inner <= innerLimit) && success; inner++)
    {
        if( !doInnerStuff() )
        {
            success = false;
        }
    }

    if( success )
    {
        success = doOuterStuff();
    }
}