¿Cómo evito una devolución inútil en un método Java?

Tengo una situación en la que siempre se alcanzará la returndeclaración anidada en dos forbucles, en teoría.

El compilador no está de acuerdo y requiere una returndeclaración fuera del forciclo. Me gustaría conocer una forma elegante de optimizar este método que está más allá de mi comprensión actual, y ninguna de mis implementaciones de ruptura intentadas parece funcionar.

Attached es un método de una asignación que genera enteros aleatorios y devuelve las iteraciones recorridas hasta que se encuentra un segundo entero aleatorio, generado dentro de un rango pasado al método como un parámetro 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
}

La heurística del compilador nunca le permitirá omitir la última return. Si está seguro de que nunca se alcanzará, lo reemplazaría con un throwpara aclarar la situación.

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

Como señaló @BoristheSpider, puede asegurarse de que la segunda returndeclaración sea semánticamente inalcanzable:

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

Se compila y funciona bien. Y si alguna vez obtiene un ArrayIndexOutOfBoundsException, sabrá que la implementación fue semánticamente incorrecta, sin tener que arrojar nada explícitamente.

Como preguntaste sobre cómo romper dos forbucles, puedes usar una etiqueta para hacerlo (mira el ejemplo a continuación):

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

Mientras que una aserción es una buena solución rápida. En general, este tipo de problemas significa que su código es demasiado complicado. Cuando miro su código, es obvio que realmente no desea que una matriz contenga números anteriores. Quieres 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();

Ahora tenga en cuenta que lo que estamos devolviendo es en realidad el tamaño del conjunto. La complejidad del código ha disminuido de cuadrática a lineal y es inmediatamente más legible.

Ahora podemos darnos cuenta de que ni siquiera necesitamos ese countíndice:

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

Como su valor de retorno se basa en la variable del ciclo externo, simplemente puede alterar la condición del ciclo externo count < rangey luego devolver este último valor (que acaba de omitir) al final de la función:

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

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

De esta forma, no es necesario introducir un código que nunca se alcanzará.

Utilice una variable temporal, por ejemplo, "resultado", y elimine el retorno interno. Cambie el bucle for por un bucle while con la condición adecuada. Para mí, siempre es más elegante tener solo un retorno como última declaración de la función.

Tal vez esto sea una indicación de que debería reescribir su código. Por ejemplo:

1. Cree una matriz de enteros 0 .. rango-1. Establezca todos los valores en 0.
2. Realiza un bucle. En el ciclo, genere un número aleatorio. Mire en su lista, en ese índice, para ver si el valor es 1. Si lo es, salga del ciclo. De lo contrario, establezca el valor en ese índice en 1
3. Cuente el número de unos en la lista y devuelva ese valor.

Los métodos que tienen una declaración de retorno y tienen un bucle / bucles dentro de ellos siempre requieren una declaración de devolución fuera del bucle (s). Incluso si esta declaración fuera del ciclo nunca se alcanza. En tales casos, para evitar declaraciones de retorno innecesarias, puede definir una variable del tipo respectivo, un entero en su caso, al comienzo del método, es decir, antes y fuera de los bucles respectivos. Cuando se alcanza el resultado deseado dentro del ciclo, puede atribuir el valor respectivo a esta variable predefinida y usarlo para la declaración de retorno fuera del ciclo.

Como desea que su método devuelva el primer resultado cuando rInt [i] es igual a rInt [count], implementar solo la variable mencionada anteriormente no es suficiente porque el método devolverá el último resultado cuando rInt [i] es igual a rInt [count]. Una opción es implementar dos "sentencias de interrupción" que se llaman cuando tenemos el resultado deseado. Entonces, el método se verá así:

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

Estoy de acuerdo en que se debería lanzar una excepción cuando ocurra una declaración inalcanzable. Solo quería mostrar cómo el mismo método puede hacer esto de una manera más legible (se requieren secuencias de 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
}