Comment éviter un retour inutile dans une méthode Java?

J'ai une situation où le return déclaration imbriquée dans deux forboucles sera toujours atteinte, en théorie.

Le compilateur n'est pas d'accord et nécessite un return déclaration en dehors de la forboucle. J'aimerais connaître un moyen élégant d'optimiser cette méthode qui dépasse ma compréhension actuelle, et aucune de mes tentatives d'implémentation de break ne semble fonctionner.

Ci-joint une méthode à partir d'une affectation qui génère des entiers aléatoires et retourne les itérations parcourues jusqu'à ce qu'un deuxième entier aléatoire soit trouvé, généré dans une plage transmise à la méthode en tant que paramètre 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'heuristique du compilateur ne vous laissera jamais omettre le dernier return. Si vous êtes sûr qu'il ne sera jamais atteint, je le remplacerais par un throwpour clarifier la situation.

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

Comme @BoristheSpider l'a souligné, vous pouvez vous assurer que la deuxième returninstruction est sémantiquement inaccessible:

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

Compile et fonctionne bien. Et si jamais vous obtenez un, ArrayIndexOutOfBoundsExceptionvous saurez que l'implémentation était sémantiquement fausse, sans avoir à lancer quoi que ce soit explicitement.

Puisque vous avez posé une question sur la rupture de deux forboucles, vous pouvez utiliser une étiquette pour le faire (voir l'exemple ci-dessous):

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

Alors qu'une affirmation est une bonne solution rapide. En général, ce genre de problèmes signifie que votre code est trop compliqué. Quand je regarde votre code, il est évident que vous ne voulez pas vraiment qu'un tableau contienne les numéros précédents. Vous voulez 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();

Notez maintenant que ce que nous retournons est en fait la taille de l'ensemble. La complexité du code est passée de quadratique à linéaire et il est immédiatement plus lisible.

Maintenant, nous pouvons réaliser que nous n'avons même pas besoin de cet countindex:

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

Comme votre valeur de retour est basée sur la variable de la boucle externe, vous pouvez simplement modifier la condition de la boucle externe, count < rangepuis renvoyer cette dernière valeur (que vous venez d'omettre) à la fin de la fonction:

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

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

De cette façon, vous n'avez pas besoin d'introduire du code qui ne sera jamais atteint.

Utilisez une variable temporaire, par exemple "result", et supprimez le retour interne. Changez la boucle for pour une boucle while avec la bonne condition. Pour moi, il est toujours plus élégant de n'avoir qu'un seul retour comme dernière instruction de la fonction.

Peut-être que c'est une indication que vous devriez réécrire votre code. Par exemple:

1. Créez un tableau d'entiers 0 .. range-1. Définissez toutes les valeurs sur 0.
2. Effectuez une boucle. Dans la boucle, générez un nombre aléatoire. Regardez dans votre liste, à cet index, pour voir si la valeur est 1 Si c'est le cas, sortez de la boucle. Sinon, définissez la valeur de cet index sur 1
3. Comptez le nombre de 1 dans la liste et renvoyez cette valeur.

Les méthodes qui ont une instruction return et ont une ou des boucles à l'intérieur nécessitent toujours une instruction return en dehors de la ou des boucles. Même si cette instruction en dehors de la boucle n'est jamais atteinte. Dans de tels cas, afin d'éviter des déclarations de retour inutiles, vous pouvez définir une variable du type respectif, un entier dans votre cas, au début de la méthode, c'est-à-dire avant et en dehors de la ou des boucles respectives. Lorsque le résultat souhaité à l'intérieur de la boucle est atteint, vous pouvez attribuer la valeur respective à cette variable prédéfinie et l'utiliser pour l'instruction return en dehors de la boucle.

Puisque vous voulez que votre méthode renvoie le premier résultat lorsque rInt [i] est égal à rInt [count], implémenter uniquement la variable mentionnée ci-dessus n'est pas suffisant car la méthode retournera le dernier résultat lorsque rInt [i] est égal à rInt [count]. Une des options consiste à implémenter deux "instructions break" qui sont appelées lorsque nous obtenons le résultat souhaité. Ainsi, la méthode ressemblera à quelque chose comme ceci:

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

Je suis d'accord qu'il faut lever une exception là où une déclaration inaccessible se produit. Je voulais juste montrer comment la même méthode peut faire cela de manière plus lisible (java 8 streams requis).

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
}