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

从理论上讲，我总是遇到return嵌套在两个for循环中的语句。

编译器不同意并且需要循环return外的语句for。我想知道一种优雅的方法来优化此方法，这超出了我目前的理解，并且我尝试的break实现似乎都没有用。

附带的是一个赋值方法，该赋值方法生成随机整数，并返回循环进行的迭代直到找到第二个随机整数为止，该迭代在作为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
}

编译器的试探法永远不会让您忽略最后一个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");
}

正如@BoristheSpider指出的那样，您可以确保第二条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您将知道实现在语义上是错误的，而无需显式抛出任何内容。

由于您询问要打破两个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;
}

断言是一个很好的快速解决方案。通常，这种问题意味着您的代码过于复杂。当我查看您的代码时，很明显，您实际上并不希望数组保存以前的数字。您想要一个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();

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

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

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

这样，您无需引入永远不会到达的代码。

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

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

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

具有return语句且内部具有循环的方法始终需要在循环外部具有return语句。即使从未到达循环外的此语句。在这种情况下，为了避免不必要的return语句，您可以在方法的开头（即，在各个循环之前和之外）定义各自类型的变量，在您的情况下为整数。当在循环内达到期望的结果时，可以将各自的值分配给该预定义变量，并将其用于循环外的return语句。

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

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

我同意应该在发生无法访问的语句时引发异常。只是想展示相同的方法如何以更具可读性的方式做到这一点（需要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!"));
}

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
}