Jak uniknąć bezużytecznego zwrotu w metodzie Java?

Mam sytuację, w której returninstrukcja zagnieżdżona w dwóch forpętlach teoretycznie zawsze zostanie osiągnięta.

Kompilator nie zgadza się i wymaga returninstrukcji poza forpętlą. Chciałbym poznać elegancki sposób optymalizacji tej metody, który wykracza poza moje obecne rozumienie, i żadna z moich prób implementacji przerwy nie wydaje się działać.

Attached to metoda z przypisania, która generuje losowe liczby całkowite i zwraca iteracje wykonywane cyklicznie do momentu znalezienia drugiej losowej liczby całkowitej, wygenerowanej w zakresie przekazanym do metody jako parametr 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
}

Heurystyka kompilatora nigdy nie pozwoli ci pominąć ostatniego return. Jeśli jesteś pewien, że nigdy nie zostanie osiągnięty, zastąpiłbym go znakiem, throwaby wyjaśnić sytuację.

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

Jak zauważył @BoristheSpider , możesz upewnić się, że druga returninstrukcja jest semantycznie nieosiągalna:

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

Kompiluje się i działa dobrze. A jeśli kiedykolwiek otrzymasz komunikat ArrayIndexOutOfBoundsException, będziesz wiedział, że implementacja była semantycznie błędna, bez konieczności jawnego rzucania czegokolwiek.

Ponieważ pytałeś o wyrwanie się z dwóch forpętli, możesz użyć do tego etykiety (zobacz przykład poniżej):

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

Chociaż asercja jest dobrym, szybkim rozwiązaniem. Ogólnie tego rodzaju problemy oznaczają, że Twój kod jest zbyt skomplikowany. Kiedy patrzę na twój kod, jest oczywiste, że tak naprawdę nie chcesz, aby tablica zawierała poprzednie liczby. Chcesz 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();

Zwróćmy teraz uwagę, że zwracamy w rzeczywistości rozmiar zestawu. Złożoność kodu zmniejszyła się z kwadratowej do liniowej i jest od razu bardziej czytelny.

Teraz możemy zdać sobie sprawę, że nie potrzebujemy nawet tego countindeksu:

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();

Ponieważ wartość zwracana jest oparta na zmiennej zewnętrznej pętli, możesz po prostu zmienić warunek pętli zewnętrznej na, count < rangea następnie zwrócić tę ostatnią wartość (którą właśnie ominąłeś) na końcu funkcji:

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

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

W ten sposób nie musisz wprowadzać kodu, który nigdy nie zostanie osiągnięty.

Użyj zmiennej tymczasowej, na przykład „result”, i usuń wewnętrzny zwrot. Zmień pętlę for na chwilę z odpowiednim warunkiem. Dla mnie zawsze bardziej eleganckie jest mieć tylko jeden powrót jako ostatnią instrukcję funkcji.

Może to jest wskazówka, że ​​powinieneś przepisać swój kod. Na przykład:

1. Utwórz tablicę liczb całkowitych 0 .. zakres-1. Ustaw wszystkie wartości na 0.
2. Wykonaj pętlę. W pętli wygeneruj liczbę losową. Spójrz na swoją listę, na ten indeks, aby zobaczyć, czy wartość wynosi 1. Jeśli tak, wyrwij się z pętli. W przeciwnym razie ustaw wartość tego indeksu na 1
3. Policz liczbę jedynek na liście i zwróć tę wartość.

Metody, które mają instrukcję return i mają wewnątrz pętlę / pętle, zawsze wymagają instrukcji return poza pętlą (-ami). Nawet jeśli ta instrukcja poza pętlą nigdy nie zostanie osiągnięta. W takich przypadkach, aby uniknąć niepotrzebnych instrukcji powrotu, możesz zdefiniować zmienną odpowiedniego typu, w twoim przypadku liczbę całkowitą, na początku metody, tj. Przed i poza odpowiednią pętlą (-ami). Po osiągnięciu pożądanego wyniku wewnątrz pętli można przypisać odpowiednią wartość do tej wstępnie zdefiniowanej zmiennej i użyć jej do instrukcji return poza pętlą.

Ponieważ chcesz, aby metoda zwracała pierwszy wynik, gdy rInt [i] jest równe rInt [count], zaimplementowanie tylko wyżej wymienionej zmiennej nie wystarczy, ponieważ metoda zwróci ostatni wynik, gdy rInt [i] jest równe rInt [count]. Jedną z opcji jest zaimplementowanie dwóch "instrukcji przerwania", które są wywoływane, gdy mamy pożądany wynik. Tak więc metoda będzie wyglądać mniej więcej tak:

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

Zgadzam się, że należy wrzucić wyjątek, w którym występuje stwierdzenie nieosiągalne. Chciałem tylko pokazać, jak ta sama metoda może to zrobić w bardziej czytelny sposób (wymagane strumienie 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
}