Java yönteminde gereksiz bir dönüşü nasıl önleyebilirim?

returnİki fordöngü içinde iç içe geçmiş ifadeye teorik olarak her zaman ulaşılacağı bir durumum var .

Derleyici buna katılmaz ve döngünün returndışında bir ifade gerektirir for. Şu anki anlayışımın ötesinde olan bu yöntemi optimize etmenin zarif bir yolunu bilmek istiyorum ve kırma girişimlerimden hiçbiri işe yaramıyor gibi görünüyor.

Ekte, rastgele tamsayılar üreten ve bir int parametresi olarak yönteme geçirilen bir aralık içinde oluşturulan ikinci bir rastgele tamsayı bulunana kadar tekrarlanan yinelemeleri döndüren bir atamadan bir yöntem eklenmiştir.

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
}

Derleyicinin buluşsal yöntemi sonuncuyu atlamanıza asla izin vermez return. Asla ulaşılmayacağından eminseniz throw, durumu netleştirmek için onu a ile değiştirirdim .

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

@BoristheSpider'ın belirttiği gibi , ikinci returnifadenin anlamsal olarak erişilemez olduğundan emin olabilirsiniz :

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

Derler ve iyi çalışır. Ve eğer bir ArrayIndexOutOfBoundsExceptionşey alırsanız, açıkça herhangi bir şey atmak zorunda kalmadan uygulamanın anlamsal olarak yanlış olduğunu anlarsınız.

İki fordöngüden çıkmayı sorduğunuz için, bunu yapmak için bir etiket kullanabilirsiniz (aşağıdaki örneğe bakı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;
}

İddia etmek iyi bir hızlı çözüm olsa da. Genel olarak bu tür sorunlar, kodunuzun çok karmaşık olduğu anlamına gelir. Kodunuza baktığımda, bir dizinin önceki sayıları tutmasını gerçekten istemediğiniz açık. İstersiniz 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();

Şimdi, döndürdüğümüz şeyin aslında setin boyutu olduğuna dikkat edin. Kod karmaşıklığı ikinci dereceden doğrusala düşmüştür ve hemen daha okunabilir hale gelmiştir.

Artık bu countdizine ihtiyacımız olmadığını fark edebiliriz :

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

Dönüş değeriniz dış döngünün değişkenine dayandığından, dış döngünün koşulunu değiştirebilir count < rangeve ardından bu son değeri (az önce atlamış olduğunuz) işlevin sonunda döndürebilirsiniz:

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

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

Bu şekilde asla ulaşılamayacak bir kod girmenize gerek kalmaz.

Geçici değişken kullanın, örneğin "sonuç" ve iç dönüşü kaldırın. Bir while döngüsü için for döngüsünü uygun koşulla değiştirin. Bana göre, işlevin son ifadesi olarak yalnızca bir dönüşün olması her zaman daha zariftir.

Belki de bu, kodunuzu yeniden yazmanız gerektiğinin bir göstergesidir. Örneğin:

1. 0 .. aralık-1 tamsayılarından oluşan bir dizi oluşturun. Tüm değerleri 0 olarak ayarlayın.
2. Bir döngü gerçekleştirin. Döngüde rastgele bir sayı oluşturun. Değerin 1 olup olmadığını görmek için listenize, o dizine bakın, eğer öyleyse, döngüden çıkın. Aksi takdirde, bu dizindeki değeri 1 olarak ayarlayın
3. Listedeki 1'leri sayın ve bu değeri döndürün.

Return ifadesine sahip olan ve içinde döngü / döngü bulunan yöntemler her zaman döngü (ler) dışında bir dönüş ifadesi gerektirir. Döngünün dışındaki bu ifadeye asla ulaşılmasa bile. Bu gibi durumlarda, gereksiz dönüş ifadelerinden kaçınmak için, yöntemin başlangıcında, yani ilgili döngü (ler) in öncesinde ve dışında ilgili türde bir değişken, sizin durumunuzda bir tamsayı tanımlayabilirsiniz. Döngü içinde istenen sonuca ulaşıldığında, ilgili değeri bu önceden tanımlanmış değişkene atayabilir ve onu döngünün dışındaki return ifadesi için kullanabilirsiniz.

Yönteminizin rInt [i] eşittir rInt [sayım] olduğunda ilk sonucu döndürmesini istediğiniz için, yalnızca yukarıda belirtilen değişkeni uygulamak yeterli değildir çünkü yöntem rInt [i], rInt [sayım] 'a eşit olduğunda son sonucu döndürecektir. Seçeneklerden biri, istenen sonuca sahip olduğumuzda çağrılan iki "break ifadesi" uygulamaktır. Dolayısıyla yöntem şuna benzer:

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

Ulaşılamaz ifadenin ortaya çıktığı yerde bir istisna atılması gerektiğine katılıyorum. Sadece aynı yöntemin bunu daha okunaklı bir şekilde nasıl yapabileceğini göstermek istedim (java 8 akışı gereklidir).

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
}