Як уникнути марного повернення методом Java?

У мене є ситуація, коли returnтвердження, вкладене в дві forпетлі, завжди буде досягнуто теоретично.

Компілятор не погоджується і вимагає returnзаяви поза межами forциклу. Я хотів би знати елегантний спосіб оптимізації цього методу, який не відповідає моєму теперішньому розумінню, і жодна з моїх спроб реалізації перерви, здається, не спрацює.

Вкладений - це метод із призначення, який генерує випадкові цілі числа та повертає ітерації, прокручені до тих пір, поки не буде знайдено друге випадкове ціле число, генерується в межах діапазону, переданого методу у вигляді параметра 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;
}

Таким чином вам не потрібно вводити код, який ніколи не буде досягнутий.

Використовуйте змінну temp, наприклад "результат" та видаліть внутрішнє повернення. На певний час змініть цикл for на відповідний стан. Мені завжди елегантніше мати лише одне повернення як останнє твердження функції.

Можливо, це є ознакою того, що вам слід переписати свій код. Наприклад:

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

Методи, які мають оператор повернення і мають цикл / цикли всередині них, завжди вимагають оператора повернення поза циклами. Навіть якщо це твердження поза циклом ніколи не буде досягнуто. У таких випадках, щоб уникнути зайвих операторів повернення, ви можете визначити змінну відповідного типу, ціле число у вашому випадку, на початку методу, тобто перед і поза відповідними циклами. Коли досягнутий бажаний результат всередині циклу, ви можете віднести відповідне значення до цієї заздалегідь визначеної змінної та використовувати її для оператора повернення поза циклом.

Оскільки ви хочете, щоб ваш метод повернув перший результат, коли 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
}