Wie vermeide ich eine nutzlose Rückgabe in einer Java-Methode?

Ich habe eine Situation, in der die returnin zwei forSchleifen verschachtelte Anweisung theoretisch immer erreicht wird.

Der Compiler ist anderer Meinung und benötigt eine returnAnweisung außerhalb der forSchleife. Ich würde gerne einen eleganten Weg kennen, um diese Methode zu optimieren, der über mein derzeitiges Verständnis hinausgeht, und keine meiner versuchten Implementierungen von break scheint zu funktionieren.

Im Anhang befindet sich eine Methode aus einer Zuweisung, die zufällige Ganzzahlen generiert und die durchlaufenen Iterationen zurückgibt, bis eine zweite zufällige Ganzzahl gefunden wird, die innerhalb eines Bereichs generiert wird, der als int-Parameter an die Methode übergeben wird.

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
}

Mit den Heuristiken des Compilers können Sie niemals die letzte weglassen return. Wenn Sie sicher sind, dass es niemals erreicht wird, würde ich es durch ein ersetzen throw, um die Situation klarer zu machen.

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

Wie @BoristheSpider hervorhob, können Sie sicherstellen, dass die zweite returnAnweisung semantisch nicht erreichbar ist:

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

Kompiliert und läuft gut. Und wenn Sie jemals eine bekommen ArrayIndexOutOfBoundsException, wissen Sie, dass die Implementierung semantisch falsch war, ohne explizit etwas werfen zu müssen.

Da Sie nach dem Ausbrechen von zwei forSchleifen gefragt haben , können Sie dazu ein Etikett verwenden (siehe Beispiel unten):

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

Während eine Behauptung eine gute schnelle Lösung ist. Im Allgemeinen bedeutet diese Art von Problemen, dass Ihr Code zu kompliziert ist. Wenn ich mir Ihren Code anschaue, ist es offensichtlich, dass Sie nicht wirklich möchten, dass ein Array vorherige Nummern enthält. Du willst ein 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();

Beachten Sie nun, dass das, was wir zurückgeben, tatsächlich die Größe des Sets ist. Die Codekomplexität hat sich von quadratisch zu linear verringert und ist sofort besser lesbar.

Jetzt können wir erkennen, dass wir diesen countIndex nicht einmal brauchen :

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

Da Ihr Rückgabewert auf der Variablen der äußeren Schleife basiert, können Sie einfach den Zustand der äußeren Schleife ändern count < rangeund dann diesen letzten Wert (den Sie gerade weggelassen haben) am Ende der Funktion zurückgeben:

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

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

Auf diese Weise müssen Sie keinen Code einführen, der niemals erreicht wird.

Verwenden Sie eine temporäre Variable, zum Beispiel "result", und entfernen Sie die innere Rückgabe. Ändern Sie die for-Schleife für eine while-Schleife unter den richtigen Bedingungen. Für mich ist es immer eleganter, nur eine Rückgabe als letzte Anweisung der Funktion zu haben.

Vielleicht ist dies ein Hinweis darauf, dass Sie Ihren Code neu schreiben sollten. Beispielsweise:

1. Erstellen Sie ein Array von Ganzzahlen 0 .. range-1. Setzen Sie alle Werte auf 0.
2. Führen Sie eine Schleife durch. Generieren Sie in der Schleife eine Zufallszahl. Sehen Sie in Ihrer Liste nach diesem Index, um festzustellen, ob der Wert 1 ist. Wenn dies der Fall ist, brechen Sie aus der Schleife aus. Andernfalls setzen Sie den Wert an diesem Index auf 1
3. Zählen Sie die Anzahl der Einsen in der Liste und geben Sie diesen Wert zurück.

Methoden mit einer return-Anweisung und einer Schleife / Schleifen erfordern immer eine return-Anweisung außerhalb der Schleife (n). Auch wenn diese Aussage außerhalb der Schleife nie erreicht wird. In solchen Fällen können Sie zu Beginn der Methode, dh vor und außerhalb der jeweiligen Schleife (n), eine Variable des jeweiligen Typs definieren, in Ihrem Fall eine Ganzzahl, um unnötige Rückgabeanweisungen zu vermeiden. Wenn das gewünschte Ergebnis innerhalb der Schleife erreicht ist, können Sie dieser vordefinierten Variablen den entsprechenden Wert zuweisen und ihn für die return-Anweisung außerhalb der Schleife verwenden.

Da Ihre Methode das erste Ergebnis zurückgeben soll, wenn rInt [i] gleich rInt [count] ist, reicht es nicht aus, nur die oben genannte Variable zu implementieren, da die Methode das letzte Ergebnis zurückgibt, wenn rInt [i] gleich rInt [count] ist. Eine Möglichkeit besteht darin, zwei "break-Anweisungen" zu implementieren, die aufgerufen werden, wenn das gewünschte Ergebnis erzielt wird. Die Methode sieht also ungefähr so ​​aus:

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

Ich bin damit einverstanden, dass eine Ausnahme ausgelöst wird, wenn eine nicht erreichbare Aussage auftritt. Ich wollte nur zeigen, wie dieselbe Methode dies besser lesbar macht (Java 8-Streams erforderlich).

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
}