Как избежать бесполезного возврата в методе 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;
}

Хотя assert - хорошее быстрое решение. В общем, такого рода проблемы означают, что ваш код слишком сложен. Когда я смотрю на ваш код, становится очевидно, что вы действительно не хотите, чтобы массив содержал предыдущие числа. Вы хотите 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;
}

Таким образом, вам не нужно вводить код, который никогда не будет достигнут.

Используйте временную переменную, например «результат», и удалите внутренний возврат. Измените цикл for на цикл while с правильным условием. Для меня всегда более элегантно иметь только один возврат в качестве последнего оператора функции.

Может быть, это признак того, что вам следует переписать свой код. Например:

1. Создайте массив целых чисел 0 .. диапазон-1. Установите все значения на 0.
2. Выполните петлю. В цикле сгенерируйте случайное число. Посмотрите в своем списке на этот индекс, чтобы увидеть, равно ли значение 1. Если это так, выйдите из цикла. В противном случае установите значение этого индекса равным 1
3. Подсчитайте количество единиц в списке и верните это значение.

Методы, которые имеют оператор возврата и внутри них цикл / циклы, всегда требуют оператора возврата вне цикла (ов). Даже если этот оператор вне цикла никогда не достигается. В таких случаях, чтобы избежать ненужных операторов возврата, вы можете определить переменную соответствующего типа, целое число в вашем случае, в начале метода, то есть до и за пределами соответствующего цикла (ов). Когда желаемый результат внутри цикла будет достигнут, вы можете присвоить соответствующее значение этой предопределенной переменной и использовать его для оператора возврата вне цикла.

Поскольку вы хотите, чтобы ваш метод возвращал первый результат, когда rInt [i] равняется rInt [count], реализации только вышеупомянутой переменной недостаточно, потому что метод вернет последний результат, когда rInt [i] равно rInt [count]. Один из вариантов - реализовать два «оператора прерывания», которые вызываются, когда мы получаем желаемый результат. Итак, метод будет выглядеть примерно так:

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
}