ฉันจะหลีกเลี่ยงผลตอบแทนที่ไร้ประโยชน์ในวิธี Java ได้อย่างไร

ฉันมีสถานการณ์ที่returnคำสั่งที่ซ้อนอยู่ในสองforลูปจะมาถึงเสมอในทางทฤษฎี

คอมไพเลอร์ไม่เห็นด้วยและต้องการreturnคำสั่งนอกforลูป ฉันต้องการทราบวิธีที่สวยงามในการเพิ่มประสิทธิภาพวิธีนี้ซึ่งอยู่นอกเหนือความเข้าใจในปัจจุบันของฉันและดูเหมือนว่าการใช้งานการหยุดพักจะไม่ได้ผล

Attached เป็นวิธีการจากการกำหนดที่สร้างจำนวนเต็มแบบสุ่มและส่งกลับการวนซ้ำที่วนซ้ำจนกว่าจะพบจำนวนเต็มสุ่มที่สองซึ่งสร้างขึ้นภายในช่วงที่ส่งผ่านไปยังเมธอดเป็นพารามิเตอร์ 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
}

ฮิวริสติกของคอมไพเลอร์จะไม่ยอมให้คุณละเว้นสุดท้าย returnการวิเคราะห์พฤติกรรมของคอมไพเลอร์จะไม่ให้คุณละเว้นสุดท้ายหากคุณแน่ใจว่าจะไม่มีวันไปถึงฉันจะแทนที่ด้วยthrowเพื่อให้สถานการณ์ชัดเจน

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 ชี้ให้เห็นว่าคุณสามารถตรวจสอบให้แน่ใจว่าreturnคำสั่งที่สองไม่สามารถเข้าถึงความหมายได้:

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

รวบรวมและทำงานได้ดี และถ้าคุณได้รับArrayIndexOutOfBoundsExceptionคุณจะรู้ว่าการใช้งานนั้นผิดพลาดโดยไม่จำเป็นต้องโยนอะไรออกไปอย่างชัดเจน

เนื่องจากคุณถามเกี่ยวกับการแยกสองforลูปออกคุณสามารถใช้ป้ายกำกับเพื่อทำสิ่งนั้นได้ (ดูตัวอย่างด้านล่าง):

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

ในขณะที่การยืนยันเป็นวิธีแก้ปัญหาที่รวดเร็วดี โดยทั่วไปปัญหาประเภทนี้หมายความว่าโค้ดของคุณซับซ้อนเกินไป เมื่อฉันดูรหัสของคุณเห็นได้ชัดว่าคุณไม่ต้องการให้อาร์เรย์เก็บตัวเลขก่อนหน้านี้ คุณต้องการ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();

ตอนนี้โปรดทราบว่าสิ่งที่เรากลับมาคือขนาดของชุดจริงๆ ความซับซ้อนของโค้ดลดลงจากกำลังสองเป็นเชิงเส้นและสามารถอ่านได้มากขึ้นทันที

ตอนนี้เรารู้แล้วว่าเราไม่ต้องการcountดัชนีนั้นด้วยซ้ำ:

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

เนื่องจากค่าส่งคืนของคุณขึ้นอยู่กับตัวแปรของวงนอกคุณสามารถเปลี่ยนเงื่อนไขของวงนอกเป็นcount < rangeแล้วส่งคืนค่าสุดท้ายนี้ (ซึ่งคุณเพิ่งข้ามไป) ในตอนท้ายของฟังก์ชัน:

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

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

ด้วยวิธีนี้คุณไม่จำเป็นต้องแนะนำรหัสที่ไม่มีวันเข้าถึง

ใช้ตัวแปร temp ตัวอย่างเช่น "ผลลัพธ์" และลบผลตอบแทนภายใน เปลี่ยนลูป for a while loop ด้วยเงื่อนไขที่เหมาะสม สำหรับฉันแล้วมันสวยกว่าเสมอที่จะมีผลตอบแทนเพียงครั้งเดียวเป็นคำสั่งสุดท้ายของฟังก์ชัน

บางทีนี่อาจเป็นข้อบ่งชี้ว่าคุณควรเขียนโค้ดของคุณใหม่ ตัวอย่างเช่น:

1. สร้างอาร์เรย์ของจำนวนเต็ม 0 .. range-1 ตั้งค่าทั้งหมดเป็น 0
2. ดำเนินการวนซ้ำ ในลูปสร้างตัวเลขสุ่ม ดูในรายการของคุณที่ดัชนีนั้นเพื่อดูว่าค่าเป็น 1 หรือไม่ให้แยกออกจากลูป มิฉะนั้นให้ตั้งค่าที่ดัชนีนั้นเป็น 1
3. นับจำนวน 1 ในรายการและส่งคืนค่านั้น

เมธอดที่มีคำสั่ง return และมี loop / loops อยู่ภายในนั้นจะต้องมีคำสั่ง return ที่อยู่นอกลูปเสมอ แม้ว่าจะไม่มีวันถึงคำสั่งนอกลูปนี้ก็ตาม ในกรณีเช่นนี้เพื่อหลีกเลี่ยงข้อความแสดงผลที่ไม่จำเป็นคุณสามารถกำหนดตัวแปรของประเภทที่เกี่ยวข้องจำนวนเต็มในกรณีของคุณที่จุดเริ่มต้นของวิธีการเช่นก่อนและนอกลูปตามลำดับ เมื่อถึงผลลัพธ์ที่ต้องการภายในลูปคุณสามารถกำหนดค่าที่เกี่ยวข้องกับตัวแปรที่กำหนดไว้ล่วงหน้านี้และใช้สำหรับคำสั่ง return นอกลูป

เนื่องจากคุณต้องการให้เมธอดของคุณส่งคืนผลลัพธ์แรกเมื่อ rInt [i] เท่ากับ rInt [count] การใช้ตัวแปรที่กล่าวถึงข้างต้นเท่านั้นจึงไม่เพียงพอเนื่องจากเมธอดจะส่งคืนผลลัพธ์สุดท้ายเมื่อ rInt [i] เท่ากับ rInt [count] ทางเลือกหนึ่งคือการใช้ "break statement" สองรายการที่เรียกเมื่อเราได้ผลลัพธ์ที่ต้องการ ดังนั้นวิธีการจะมีลักษณะดังนี้:

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

ฉันยอมรับว่าเราควรโยนข้อยกเว้นเมื่อมีข้อความที่ไม่สามารถเข้าถึงได้เกิดขึ้น แค่อยากจะแสดงให้เห็นว่าวิธีการเดียวกันนี้สามารถอ่านได้อย่างไร (ต้องใช้ java 8 stream)

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
}