Come posso evitare un ritorno inutile in un metodo Java?

Ho una situazione in cui l' returnistruzione annidata in due forcicli verrà sempre raggiunta, in teoria.

Il compilatore non è d'accordo e richiede returnun'istruzione al di fuori del forciclo. Mi piacerebbe conoscere un modo elegante per ottimizzare questo metodo che sia al di là della mia attuale comprensione e nessuna delle mie tentate implementazioni di break sembra funzionare.

In allegato è un metodo da un'assegnazione che genera numeri interi casuali e restituisce le iterazioni ripetute fino a quando non viene trovato un secondo numero intero casuale, generato all'interno di un intervallo passato nel metodo come parametro 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
}

L'euristica del compilatore non ti consentirà mai di omettere l'ultimo return. Se sei sicuro che non verrà mai raggiunto, lo sostituisco con un throwper rendere chiara la situazione.

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

Come ha sottolineato @BoristheSpider, puoi assicurarti che la seconda returnaffermazione sia semanticamente irraggiungibile:

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

Compila e funziona bene. E se mai ArrayIndexOutOfBoundsExceptionne avrai una , saprai che l'implementazione era semanticamente sbagliata, senza dover lanciare esplicitamente nulla.

Dato che hai chiesto di spezzare due forloop, puoi usare un'etichetta per farlo (vedi l'esempio sotto):

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

Mentre un'affermazione è una buona soluzione rapida. In generale questo tipo di problemi significa che il tuo codice è troppo complicato. Quando guardo il tuo codice, è ovvio che non vuoi davvero che un array contenga i numeri precedenti. Vuoi un 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();

Ora nota che ciò che stiamo restituendo è in realtà la dimensione del set. La complessità del codice è diminuita da quadratica a lineare ed è immediatamente più leggibile.

Ora possiamo renderci conto che non abbiamo nemmeno bisogno di quell'indice 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();

Poiché il valore di ritorno si basa sulla variabile del ciclo esterno, potresti semplicemente modificare la condizione del ciclo esterno count < rangee quindi restituire quest'ultimo valore (che hai appena omesso) alla fine della funzione:

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

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

In questo modo non è necessario introdurre codice che non verrà mai raggiunto.

Usa una variabile temporanea, ad esempio "risultato", e rimuovi il ritorno interno. Modificare il ciclo for per un ciclo while con la condizione corretta. Per me è sempre più elegante avere un solo ritorno come ultima istruzione della funzione.

Forse questa è un'indicazione che dovresti riscrivere il tuo codice. Per esempio:

1. Crea un array di numeri interi 0 .. range-1. Imposta tutti i valori su 0.
2. Esegui un loop. Nel ciclo, genera un numero casuale. Guarda nella tua lista, in quell'indice, per vedere se il valore è 1 Se lo è, esci dal ciclo. Altrimenti, imposta il valore di quell'indice su 1
3. Contare il numero di 1 nell'elenco e restituire quel valore.

I metodi che hanno un'istruzione return e hanno un ciclo / cicli al loro interno richiedono sempre un'istruzione return al di fuori dei cicli. Anche se questa istruzione al di fuori del ciclo non viene mai raggiunta. In questi casi, per evitare inutili dichiarazioni di ritorno, potresti definire una variabile del rispettivo tipo, un intero nel tuo caso, all'inizio del metodo, cioè prima e al di fuori dei rispettivi cicli. Quando viene raggiunto il risultato desiderato all'interno del ciclo, è possibile attribuire il rispettivo valore a questa variabile predefinita e utilizzarlo per l'istruzione return al di fuori del ciclo.

Poiché vuoi che il tuo metodo restituisca il primo risultato quando rInt [i] è uguale a rInt [count], implementare solo la variabile sopra menzionata non è sufficiente perché il metodo restituirà l'ultimo risultato quando rInt [i] è uguale a rInt [count]. Una delle opzioni è implementare due "istruzioni break" che vengono chiamate quando si ha il risultato desiderato. Quindi, il metodo sarà simile a questo:

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

Sono d'accordo sul fatto che si dovrebbe lanciare un'eccezione dove si verifica un'istruzione irraggiungibile. Volevo solo mostrare come lo stesso metodo può farlo in modo più leggibile (java 8 stream richiesti).

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
}