JavaRush /จาวาบล็อก /Random-TH /ในขณะที่วนซ้ำใน Java

ในขณะที่วนซ้ำใน Java

เผยแพร่ในกลุ่ม

การแนะนำ

โปรแกรมแรกสุดของเราคือลำดับของคำสั่งที่ถูกดำเนินการทีละคำสั่ง ไม่มีส้อม นี่คือ HelloWorld ซึ่งส่งออกวลีทักทายและการคำนวณทางคณิตศาสตร์ไปยังคอนโซล หลังจากโปรแกรมแรก เราเรียนรู้ที่จะแยกสาขา นั่นคือ โปรแกรมดำเนินการบางอย่างขึ้นอยู่กับเงื่อนไข ต่อไปนี้คือวิธีที่คุณสามารถเขียนโค้ดให้เครื่องปรับอากาศเปิดเพื่อให้ระบบทำความร้อนและความเย็น:
if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort
    heaterOn();
เรามาทำตามขั้นตอนต่อไปกันดีกว่า ในชีวิตประจำวัน เรามักจะกระทำการกระทำที่ซ้ำซากจำเจ เช่น การปอกแอปเปิ้ลเป็นพาย กระบวนการอันน่าทึ่งนี้สามารถอธิบายได้ดังนี้:
  1. หากมีแอปเปิ้ลอยู่ในกะละมัง ให้ทำตามขั้นตอนที่ 1.1 ถึง 1.4:

    1. 1.1. หยิบแอปเปิ้ล
    2. 1.2. ทำความสะอาดและหั่นเป็นชิ้น
    3. 1.3. วางบนฐานของพายขนมในกระทะ
    4. 1.4. กลับไปที่ขั้นตอนที่ 1 กัน
ผู้ดำเนินการในขณะที่ - 2
สมมติว่าคุณมีแอปเปิ้ล 10 ผล 2 มือ และมีด 1 อัน ในชีวิต คุณทำความสะอาดทั้งสิบอย่างสม่ำเสมอ โดยใช้อัลกอริธึมเดียวกัน คุณจะทำให้โปรแกรมดำเนินการซ้ำกับแอปเปิ้ลแต่ละตัวได้อย่างไร?
  • ให้เราผูกมัดตัวเองเข้ากับจำนวนแอปเปิ้ล แต่ถ้าเรามีจำนวนแอปเปิ้ลน้อย คำสั่งบางคำสั่งก็จะถูกดำเนินการอย่างไร้ประโยชน์โดยไม่มี "น้ำหนักบรรทุก" (และบางที เราอาจจะตัดตัวเองในขณะที่ปอกแอปเปิ้ลที่ไม่มีอยู่จริง)
  • หากมีแอปเปิลมากกว่าทีมงานแปรรูปของเรา ผลิตภัณฑ์บางส่วนอาจเข้าสู่สถานะไม่แปรรูป
  • “โค้ด” ดังกล่าวอ่านยาก มีการซ้ำซ้อนจำนวนมาก และแก้ไขได้ยาก

ลูปเป็นตัวดำเนินการสำหรับการดำเนินการหลายครั้ง

Java while loop (vile loop) ทำงานได้ดีในกรณีของเรา การออกแบบนี้จัดการดำเนินการหลายอย่างให้เป็นโครงสร้างที่กระชับและเข้าใจได้ อัลกอริธึม while สำหรับการตัดแอปเปิ้ลสำหรับพายใน Java อาจมีลักษณะดังนี้:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');

ไวยากรณ์คำสั่ง

วิธีแรกในการอธิบายคำสั่ง while มีดังนี้:
while(Логическое выражение) {
	// Loop body - periodically executed statement(s)
}
ทำได้ดังนี้ (ทีละขั้นตอน):
  1. เราประเมินเงื่อนไขบูลีนที่ตามหลังในขณะที่อยู่ในวงเล็บ
  2. หากเงื่อนไขลอจิคัลเป็นจริง ตัวดำเนินการในส่วนเนื้อหาของลูปจะถูกดำเนินการ หลังจากดำเนินการตัวดำเนินการสุดท้ายในส่วนเนื้อหาของลูป ให้ไปที่ขั้นตอนที่ 1
  3. หากเงื่อนไขลอจิคัลเป็นเท็จ เราจะไปที่คำสั่งแรกที่อยู่นอกลูป while

วนซ้ำโดยมีเงื่อนไขเบื้องต้น

เนื่องจากก่อนที่จะดำเนินการเนื้อความของลูป เราจะคำนวณนิพจน์เชิงตรรกะล่วงหน้าเสมอ (เงื่อนไขสำหรับการเข้าสู่ลูป) ในขณะที่ประเภทนี้มักเรียกว่าลูปที่มีเงื่อนไขเบื้องต้น มาสร้างตารางของจำนวนเต็มสิบตัวแรกที่กำลังบวกของตัวเลขกันดีกว่า:
public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(power <= 10) { // loop entry condition
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
    }
}
ผลลัพธ์เอาต์พุตคอนโซล:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

วนซ้ำกับเงื่อนไขภายหลัง

วงจรประเภทที่สอง:
do {
    // Loop body - periodically executed statement(s)
}while (Логическое выражение);
ดำเนินการดังต่อไปนี้ (ขั้นตอน):
  1. เนื้อความของลูปถูกดำเนินการ (ทันทีหลังจากคีย์เวิร์ด do)
  2. เราประเมินเงื่อนไขบูลีนที่ตามหลังในขณะที่อยู่ในวงเล็บ
  3. หากเงื่อนไขลอจิคัลเป็นจริง ให้ไปที่ขั้นตอนที่ 1
  4. หากเงื่อนไขลอจิคัลเป็นเท็จ เราจะไปที่คำสั่งแรกที่อยู่นอกลูป while
ข้อแตกต่างหลักสองประการจากลูปประเภทก่อนหน้า: เนื้อความของลูปถูกดำเนินการอย่างน้อยหนึ่งครั้ง และเงื่อนไขตรรกะจะถูกตรวจสอบหลังจากเนื้อความของลูปถูกดำเนินการ ดังนั้นการวนซ้ำ while ประเภทนี้จึงเรียกว่าการวนซ้ำภายหลังเงื่อนไข ครั้งนี้เราจะแสดงตารางเลขยกกำลังไม่เกิน 10,000 ดังนี้
public static void main(String[] args) {
    int number = 3;// Number to be raised to a power
    int result = number;// Result of exponentiation
    int power = 1;// Initial exponent
    do {
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        result = result * number;
    }while (result < 10000); // loop exit condition
ผลลัพธ์เอาต์พุตคอนโซล:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
Process finished with exit code 0
ให้ความสนใจกับการเปลี่ยนแปลงในโค้ด โดยเปรียบเทียบกับเวอร์ชันของลูปที่มีเงื่อนไขเบื้องต้น

ข้อเท็จจริงที่น่าสนใจเกี่ยวกับการทำงานกับลูป

คำสั่งควบคุมในส่วนเนื้อความของลูป

มีสองคำสั่งที่ส่งผลต่อความคืบหน้าของลูป: ตัวแบ่ง คุณสมบัติที่เราจะแสดงในบทถัดไป และ ดำเนินการต่อ.
  • ดำเนินการต่อ – หยุดการทำงานของเนื้อความของลูปปัจจุบันและย้ายไปยังนิพจน์เชิงตรรกะของตัวดำเนินการ while หากนิพจน์ที่คำนวณแล้วเป็นจริง การดำเนินการของลูปจะดำเนินต่อไป
  • break – หยุดการทำงานของลูปปัจจุบันทันทีและข้ามไปยังคำสั่งแรกที่อยู่ด้านนอก ดังนั้นการดำเนินการของลูปปัจจุบันจึงถูกขัดจังหวะ เราจะดูรายละเอียดเพิ่มเติมในหัวข้อถัดไป
มาจำตัวอย่างผลไม้ของเรากันดีกว่า หากเราไม่แน่ใจเกี่ยวกับคุณภาพของแอปเปิ้ลที่เรานำเสนอ เราสามารถเปลี่ยนโค้ดได้โดยใช้คำสั่ง continue:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
    if (яблоко.плохое()) {  // method will return true for rotten, etc. apples
        яблоко.выкинутьВМусор();
        continue; // continue the loop, go to the condition number ofApplesIn the Basin>0
    }
    положитьВПирог(яблоко.чистить().нарезать());
}
โครงสร้าง continueมักจะใช้เมื่ออยู่ในเนื้อหาของลูปจำเป็นต้องดำเนินการคำสั่งเมื่อมีเงื่อนไขบางอย่างเกิดขึ้น เช่น เพื่อดำเนินการเมื่อเซ็นเซอร์ในอุปกรณ์ถูกกระตุ้น (ไม่เช่นนั้นเพียงอ่านวงจรการอ่านตัวบ่งชี้ต่อไป) หรือ เพื่อคำนวณนิพจน์เฉพาะบางขั้นตอนของวงจรเท่านั้น ตัวอย่างสำหรับกรณีสุดท้ายคือการคำนวณแบบวนรอบ while ของผลรวมของลูกบาศก์ของจำนวนธรรมชาติที่มีกำลังสองน้อยกว่าจำนวน:
public static void main(String[] args) {
    int sum = 0;    // total amount
    int i = 0;      // starting number of the row
    int count = 20; // amount of numbers
    while(i<=count) {
        i++;        // take the next number, i++ is equivalent to i=i+1
        if (i*i<=count)  // if the square of the number is less
            continue;   // number of numbers - do not count the sum
                        // move on to the next number in the loop
        sum += i*i*i; // otherwise, we calculate the sum of cubes of numbers
    } // sum += i*i*i - notation similar to sum = sum + i*i*i
    System.out.println(sum);// print result
}

วงจรที่ไม่มีที่สิ้นสุด

คำสั่งควบคุมเหล่านี้มักใช้ในการวนซ้ำไม่สิ้นสุด มันถูกเรียกสิ่งนี้เนื่องจากเงื่อนไขการออกเชิงลอจิคัลไม่เป็นที่พอใจ ในโค้ดดูเหมือนว่า:
while(true) {
    // Loop body
}
breakในกรณีนี้ การใช้คำสั่ง เพื่อจัดระเบียบทางออก จะมีประโยชน์ การวนซ้ำประเภทนี้เกิดขึ้นเมื่อรอเงื่อนไขภายนอกที่เกิดขึ้นนอกตรรกะของเนื้อความของลูป ตัวอย่างเช่น ในเกมที่จำลองโลกเสมือนจริงรอบๆ ฮีโร่ (ออกจากลูป = ออกจากเกม) ระบบปฏิบัติการ หรือเมื่อใช้อัลกอริธึม อาจปรับปรุงผลลัพธ์ด้วยการเรียกแต่ละครั้งในลูป แต่จำกัดไว้ตามเวลาหรือการเกิดเหตุการณ์ภายนอก (หมากฮอส หมากรุก หรือการพยากรณ์อากาศ) ควรจำไว้ว่าภายใต้สภาวะปกติ การวนซ้ำไม่รู้จบเป็นปัญหาหนึ่งของความไม่เสถียรของโปรแกรม เพื่อสาธิต ให้กลับไปสู่พลังของตัวเลข:
public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(true) {
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        if (power>10)
            break; // exit from the loop
    }
}
ผลลัพธ์เอาต์พุตคอนโซล:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

ลูปซ้อนกัน

เรามาถึงหัวข้อสุดท้ายเกี่ยวกับวัฏจักรของเรา ลองคิดถึงพายแอปเปิ้ล (หวังว่าคุณจะไม่หิวในขณะนี้) และ "ห่วง" ของเรา:
  1. หากมีแอปเปิ้ลอยู่ในกะละมัง ให้ทำตามขั้นตอนที่ 1.1 ถึง 1.4:

    1. 1.1. หยิบแอปเปิ้ล
    2. 1.2. ทำความสะอาดและหั่นเป็นชิ้น
    3. 1.3. วางบนฐานของพายขนมในกระทะ
    4. 1.4. กลับไปที่ขั้นตอนที่ 1 กัน
อธิบายกระบวนการตัดเป็นชิ้น ๆ โดยละเอียด:
  1. จำนวนชิ้น = 0
  2. แม้ว่าจำนวนชิ้นจะน้อยกว่า 12 ให้ทำตามขั้นตอนที่ 2.1 ถึง 2.3

    1. 2.1. ตัดแอปเปิ้ลอีกชิ้น
    2. 2.2. จำนวนชิ้น ++
    3. 2.3. กลับไปยังขั้นตอนที่ 2
และแทรกลงในอัลกอริทึมการทำขนมของเรา:
  1. หากมีแอปเปิ้ลอยู่ในกะละมัง ให้ทำตามขั้นตอนที่ 1.1 ถึง 1.6:

    1. 1.1. หยิบแอปเปิ้ล
    2. 1.2. ลอกออก
    3. 1.3. จำนวนชิ้น = 0
    4. 1.4. Пока число долек < 12, выполнить шаги с 1.4.1 по 1.4.3
      1. 1.4.1. Отрезать очередную дольку от яблока
      2. 1.4.2. Кол-во долек ++
      3. 1.4.3. Возвращаемся на шаг 1.4
    5. 1.5. Помещаем дольки на тестовое основание пирога из теста на сковороде
    6. 1.6. Возвращаемся на шаг 1.
Получor цикл в цикле. Подобные конструкции весьма частые. Для завершающего примера построим таблицу умножения, которые школьники 90-х видели на обложках тетрадей в младших классах.
ผู้ดำเนินการในขณะที่ - 3
public static void main(String[] args) {
    // Display the values ​​of the second multiplier in the line
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;      // first multiplier, assign starting value
    while(i<10) {   // First loop, execute while the first multiplier is less than 10
        System.out.print(i + " | ");// Display the first multiplier at the beginning of the string
        int j = 2;                  // second multiplier, starting value
        while (j<10) { // Second loop, execute while the second multiplier is less than 10
            int mul=i*j; // Calculate the product of factors
            if (mul<10)  // If it contains one digit, print two spaces after it
                System.out.print(mul + "  ");
            else   // otherwise output the product and after it - one space
                System.out.print(mul + " ");
            j++;     // Increase the second multiplier by one,
        }            // Go to the beginning of the second loop (while (j<10 ).... )
        System.out.println(); // Move to the next line of output
        i++;                  // Increase the first multiplier by one,
    }                         // Go to the beginning of the first loop (while ( i<10 ) ....
}
Результат вывода на консоль:
2  3  4  5  6  7  8  9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
Циклы (в частности, оператор while) – один из фундаментальных кирпичиков построения программ. Решая задачи на JavaRush, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.
ความคิดเห็น
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION