Como posso evitar um retorno inútil em um método Java?

Eu tenho uma situação onde o return instrução aninhada em dois forloops sempre será alcançada, teoricamente.

O compilador discorda e requer um return declaração fora do forloop. Eu gostaria de saber uma maneira elegante de otimizar esse método que está além do meu entendimento atual, e nenhuma das minhas tentativas de implementação de break parece funcionar.

Attached é um método de uma atribuição que gera inteiros aleatórios e retorna as iterações percorridas até que um segundo inteiro aleatório seja encontrado, gerado dentro de um intervalo passado para o método como um 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
}

A heurística do compilador nunca permitirá que você omita o último return. Se você tiver certeza de que nunca será alcançado, eu o substituo por um throwpara esclarecer a situação.

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 @BoristheSpider apontou, você pode garantir que a segunda returninstrução seja semanticamente inacessível:

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 funciona bem. E se você receber um, ArrayIndexOutOfBoundsExceptionsaberá que a implementação estava semanticamente errada, sem ter que lançar nada explicitamente.

Como você perguntou sobre a quebra de dois forloops, você pode usar um rótulo para fazer isso (veja o exemplo abaixo):

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

Enquanto uma afirmação é uma boa solução rápida. Em geral, esse tipo de problema significa que seu código é muito complicado. Quando estou olhando para o seu código, é óbvio que você realmente não deseja que uma matriz contenha os números anteriores. Você quer um 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();

Agora observe que o que estamos retornando é, na verdade, o tamanho do conjunto. A complexidade do código diminuiu de quadrática para linear e é imediatamente mais legível.

Agora podemos perceber que nem mesmo precisamos desse 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 seu valor de retorno é baseado na variável do loop externo, você pode simplesmente alterar a condição do loop externo count < rangee retornar este último valor (que você acabou de omitir) no final da função:

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

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

Dessa forma, você não precisa introduzir um código que nunca será alcançado.

Use uma variável temporária, por exemplo "resultado", e remova o retorno interno. Altere o loop for por um loop while com a condição adequada. Para mim é sempre mais elegante ter apenas um retorno como a última instrução da função.

Talvez isso seja uma indicação de que você deve reescrever seu código. Por exemplo:

1. Crie uma matriz de inteiros 0 .. intervalo-1. Defina todos os valores como 0.
2. Execute um loop. No loop, gere um número aleatório. Olhe em sua lista, naquele índice, para ver se o valor é 1. Se for, saia do loop. Caso contrário, defina o valor nesse índice para 1
3. Conte o número de 1s na lista e retorne esse valor.

Os métodos que possuem uma instrução de retorno e um loop / loops dentro deles sempre exigem uma instrução de retorno fora do (s) loop (s). Mesmo que essa instrução fora do loop nunca seja alcançada. Nesses casos, para evitar declarações de retorno desnecessárias, você pode definir uma variável do respectivo tipo, um inteiro no seu caso, no início do método, ou seja, antes e fora do (s) respectivo (s) loop (s). Quando o resultado desejado dentro do loop for alcançado, você pode atribuir o respectivo valor a essa variável predefinida e usá-lo para a instrução de retorno fora do loop.

Como você deseja que seu método retorne o primeiro resultado quando rInt [i] for igual a rInt [contagem], implementar apenas a variável mencionada acima não é suficiente porque o método retornará o último resultado quando rInt [i] for igual a rInt [contagem]. Uma das opções é implementar duas "instruções de interrupção" que são chamadas quando temos o resultado desejado. Portanto, o método será mais ou menos assim:

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

Concordo que se deve lançar uma exceção onde ocorre uma declaração inacessível. Só queria mostrar como o mesmo método pode fazer isso de maneira mais legível (streams java 8 necessários).

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
}