如何避免 Java 方法中的无用返回？

Question

我有一种情况，理论上，嵌套在两个 for 循环中的 return 语句总是会到达。

编译器不同意并要求在for 循环之外使用return 语句。我想知道一种优化此方法的优雅方法，这超出了我目前的理解范围，而且我尝试的 break 实现似乎都不起作用。

Attached 是一种来自赋值的方法，它生成随机整数并返回循环的迭代，直到找到第二个随机整数，在作为 int 参数传递给方法的范围内生成。

private static int oneRun(int range) {
    int[] rInt = new int[range+1]; // Stores the past sequence of ints.
    rInt[0] = generator.nextInt(range); // Inital random number.

    for (int count = 1; count <= range; count++) { // Run until return.
        rInt[count] = generator.nextInt(range); // Add randint to current iteration.
        for (int i = 0; i < count; i++) { // Check for past occurence and return if found.
            if (rInt[i] == rInt[count]) {
                return count;
            }
        }
    }
    return 0; // Never reached
}

Answer 1

编译器的启发式永远不会让您省略最后一个return。如果您确定永远无法联系到它，我会将其替换为 throw 以说明情况。

private static int oneRun(int range) {
    int[] rInt = new int[range+1]; // Stores the past sequence of ints.
    rInt[0] = generator.nextInt(range); // Inital random number.

    for (int count = 1; count <= range; count++) {
        ...
    }

    throw new AssertionError("unreachable code reached");
}

Answer 2

使用临时变量，例如 "result" ，并删除内部返回。 将 for 循环更改为具有适当条件的 while 循环。 对我来说，只有一个 return 作为函数的最后一个语句总是更优雅。

Answer 3

既然你问过要打破两个for 循环，你可以使用标签来做到这一点（见下面的例子）：

private static int oneRun(int range) {
    int returnValue=-1;

    int[] rInt = new int[range+1]; // Stores the past sequence of ints.
    rInt[0] = generator.nextInt(range); // Inital random number.

    OUTER: for (int count = 1; count <= range; count++) { // Run until return.
        rInt[count] = generator.nextInt(range); // Add randint to current iteration.   
        for (int i = 0; i < count; i++) { // Check for past occurence and return if found.
            if (rInt[i] == rInt[count]) {
                returnValue = count;
                break OUTER;
            }
        }
    }
    return returnValue;
}

Answer 4

作为@BoristheSpider pointed out，您可以确保第二个return 语句在语义上不可达：

private static int oneRun(int range) {
    int[] rInt = new int[range+1]; // Stores the past sequence of ints.
    int count = 0;

    while (true) {
        rInt[count] = generator.nextInt(range); // Add randint to current iteration.
        for (int i = 0; i < count; i++) { // Check for past occurence and return if found.
            if (rInt[i] == rInt[count]) {
                return count;
            }
        }
        count++;
    }
}

编译并运行良好。如果您收到ArrayIndexOutOfBoundsException，您就会知道该实现在语义上是错误的，而无需显式抛出任何东西。

Answer 5

由于您的返回值基于外部循环的变量，您可以简单地将外部循环的条件更改为count < range，然后在函数末尾返回最后一个值（您刚刚省略）：

private static int oneRun(int range) {
    ...

    for (int count = 1; count < range; count++) {
        ...
    }
    return range;
}

这样你就不需要引入永远无法到达的代码。

Answer 6

private static int oneRun(int range) {
    int result = -1; // use this to store your result
    int[] rInt = new int[range+1]; // Stores the past sequence of ints.
    rInt[0] = generator.nextInt(range); // Inital random number.

    for (int count = 1; count <= range && result == -1; count++) { // Run until result found.
        rInt[count] = generator.nextInt(range); // Add randint to current iteration.   
        for (int i = 0; i < count && result == -1; i++) { // Check for past occurence and leave after result found.
            if (rInt[i] == rInt[count]) {
                result = count;
            }
        }
    }
    return result; // return your result
}

Answer 7

也许这表明您应该重写代码。例如：

1. 创建一个整数数组 0 .. range-1。将所有值设置为 0。
2. 执行循环。在循环中，生成一个随机数。在您的列表中查看该索引处的值是否为 1 如果是，则跳出循环。否则，将该索引处的值设置为 1
3. 计算列表中 1 的数量，并返回该值。

Answer 8

虽然断言是一个很好的快速解决方案。一般来说，这种问题意味着你的代码太复杂了。当我查看您的代码时，很明显您并不真正想要一个数组来保存以前的数字。你想要一个Set：

Set<Integer> previous = new HashSet<Integer>();

int randomInt = generator.nextInt(range);
previous.add(randomInt);

for (int count = 1; count <= range; count++) {
    randomInt = generator.nextInt(range);
    if (previous.contains(randomInt)) {
       break;
    }

    previous.add(randomInt);
}

return previous.size();

现在请注意，我们返回的实际上是集合的大小。代码复杂度从二次方降低到线性度，可读性立即提高。

现在我们可以意识到我们甚至不需要那个 count 索引：

Set<Integer> previous = new HashSet<Integer>();

int randomInt = generator.nextInt(range);

while (!previous.contains(randomInt)) {          
    previous.add(randomInt);      
    randomInt = generator.nextInt(range);
}

return previous.size();

Answer 9

具有 return 语句并在其中有一个循环的方法总是需要在循环之外有一个 return 语句。即使永远不会到达循环外的这个语句。在这种情况下，为了避免不必要的返回语句，您可以在方法的开头定义相应类型的变量，在您的情况下为整数，即在相应循环之前和之外。当达到循环内所需的结果时，您可以将相应的值赋予此预定义变量，并将其用于循环外的 return 语句。

由于您希望您的方法在 rInt[i] 等于 rInt[count] 时返回第一个结果，因此仅实现上述变量是不够的，因为该方法将在 rInt[i] 等于 rInt[ 时返回最后一个结果数数]。一种选择是实现两个“中断语句”，当我们获得所需结果时调用它们。因此，该方法将如下所示：

private static int oneRun(int range) {

        int finalResult = 0; // the above-mentioned variable
        int[] rInt = new int[range + 1];
        rInt[0] = generator.nextInt(range);

        for (int count = 1; count <= range; count++) {
            rInt[count] = generator.nextInt(range);
            for (int i = 0; i < count; i++) {
                if (rInt[i] == rInt[count]) {
                    finalResult = count;
                    break; // this breaks the inside loop
                }
            }
            if (finalResult == count) {
                break; // this breaks the outside loop
            }
        }
        return finalResult;
    }

Answer 10

我同意应该在出现无法访问的语句时抛出异常。只是想展示相同的方法如何以更易读的方式执行此操作（需要 java 8 流）。

private static int oneRun(int range) {
    int[] rInt = new int[range + 1];
    return IntStream
        .rangeClosed(0, range)
        .peek(i -> rInt[i] = generator.nextInt(range))
        .filter(i -> IntStream.range(0, i).anyMatch(j -> rInt[i] == rInt[j]))
        .findFirst()
        .orElseThrow(() -> new RuntimeException("Shouldn't be reached!"));
}