Bagaimana cara menghindari pengembalian yang tidak berguna dalam metode Java?

Saya memiliki situasi di mana returnpernyataan yang bersarang dalam dua forloop akan selalu tercapai, secara teoritis.

Kompilator tidak setuju dan membutuhkan returnpernyataan di luar forloop. Saya ingin mengetahui cara elegan untuk mengoptimalkan metode ini yang berada di luar pemahaman saya saat ini, dan tidak ada upaya penerapan break yang berhasil saya lakukan.

Terlampir adalah metode dari penugasan yang menghasilkan bilangan bulat acak dan mengembalikan iterasi yang melalui siklus hingga bilangan bulat acak kedua ditemukan, yang dihasilkan dalam rentang yang diteruskan ke metode sebagai parameter 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
}

Heuristik kompiler tidak akan pernah membiarkan Anda menghilangkan yang terakhir return. Jika Anda yakin itu tidak akan pernah tercapai, saya akan menggantinya dengan a throwuntuk memperjelas situasinya.

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

Seperti yang ditunjukkan @BoristheSpider, Anda dapat memastikan bahwa returnpernyataan kedua secara semantik tidak dapat dijangkau:

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

Mengompilasi & berjalan dengan baik. Dan jika Anda pernah mendapatkannya, ArrayIndexOutOfBoundsExceptionAnda akan tahu bahwa penerapannya salah secara semantik, tanpa harus secara eksplisit membuang apa pun.

Karena Anda bertanya tentang keluar dari dua forloop, Anda dapat menggunakan label untuk melakukannya (lihat contoh di bawah):

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

Sedangkan assert adalah solusi cepat yang bagus. Secara umum, masalah seperti ini berarti kode Anda terlalu rumit. Ketika saya melihat kode Anda, jelas bahwa Anda tidak benar-benar ingin array menyimpan nomor sebelumnya. Anda menginginkan 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();

Sekarang perhatikan bahwa apa yang kita kembalikan sebenarnya adalah ukuran set. Kompleksitas kode telah menurun dari kuadratik menjadi linier dan segera lebih mudah dibaca.

Sekarang kita dapat menyadari bahwa kita bahkan tidak membutuhkan countindeks itu:

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

Karena nilai kembalian Anda didasarkan pada variabel loop luar, Anda cukup mengubah kondisi loop luar menjadi count < rangedan kemudian mengembalikan nilai terakhir ini (yang baru saja Anda hilangkan) di akhir fungsi:

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

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

Dengan cara ini Anda tidak perlu memasukkan kode yang tidak akan pernah bisa dijangkau.

Gunakan variabel temp, misalnya "hasil", dan hapus hasil dalam. Ubah loop for untuk loop sementara dengan kondisi yang tepat. Bagi saya itu selalu lebih elegan untuk memiliki hanya satu pengembalian sebagai pernyataan terakhir dari fungsi tersebut.

Mungkin ini merupakan indikasi bahwa Anda harus menulis ulang kode Anda. Sebagai contoh:

1. Buat array bilangan bulat 0 .. range-1. Setel semua nilai menjadi 0.
2. Lakukan satu putaran. Di loop, buat nomor acak. Lihat dalam daftar Anda, pada indeks itu, untuk melihat apakah nilainya 1 Jika ya, keluarlah dari pengulangan. Jika tidak, setel nilai pada indeks itu ke 1
3. Hitung jumlah 1s dalam daftar, dan kembalikan nilai itu.

Metode yang memiliki pernyataan return dan memiliki loop / loop di dalamnya selalu membutuhkan pernyataan return di luar loop. Bahkan jika pernyataan di luar perulangan ini tidak pernah tercapai. Dalam kasus seperti itu, untuk menghindari pernyataan kembali yang tidak perlu, Anda dapat mendefinisikan variabel dari tipe masing-masing, sebuah bilangan bulat dalam kasus Anda, pada awal metode yaitu sebelum dan di luar perulangan masing-masing. Ketika hasil yang diinginkan di dalam loop tercapai, Anda dapat mengaitkan nilai masing-masing ke variabel yang ditentukan sebelumnya ini dan menggunakannya untuk pernyataan return di luar loop.

Karena Anda ingin metode Anda mengembalikan hasil pertama ketika rInt [i] sama dengan rInt [count], menerapkan hanya variabel yang disebutkan di atas tidak cukup karena metode akan mengembalikan hasil terakhir ketika rInt [i] sama dengan rInt [count]. Salah satu opsinya adalah dengan mengimplementasikan dua "pernyataan break" yang dipanggil ketika kita mendapatkan hasil yang diinginkan. Jadi, metodenya akan terlihat seperti ini:

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

Saya setuju bahwa seseorang harus memberikan pengecualian jika pernyataan yang tidak dapat dijangkau terjadi. Hanya ingin menunjukkan bagaimana metode yang sama dapat melakukan ini dengan cara yang lebih mudah dibaca (diperlukan aliran 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
}