JavaRush /Blog Java /Random-MS /Manakala Loop di Jawa

Manakala Loop di Jawa

Diterbitkan dalam kumpulan

pengenalan

Program pertama kami ialah urutan arahan yang dilaksanakan satu demi satu. Tiada garpu. Ini ialah HelloWorld, yang mengeluarkan frasa ucapan dan pengiraan aritmetik ke konsol. Selepas program pertama, kami belajar untuk cawangan, iaitu, program melakukan tindakan tertentu bergantung pada syarat. Begini cara anda boleh mengekodkan penghawa dingin untuk dihidupkan untuk pemanasan dan penyejukan:
if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort
    heaterOn();
Mari kita ambil langkah seterusnya. Dalam kehidupan seharian, kita sering melakukan tindakan yang membosankan, berulang-ulang, sebagai contoh, mengupas epal untuk pai. Proses yang menarik ini boleh digambarkan sebagai:
  1. Jika terdapat epal di dalam besen, ikuti langkah 1.1 hingga 1.4:

    1. 1.1. Ambil sebiji epal
    2. 1.2. Bersihkan dan potong menjadi kepingan
    3. 1.3. Letakkan di atas dasar pai pastri dalam kuali
    4. 1.4. Mari kita kembali ke langkah 1.
Operator sementara - 2
Katakan anda mempunyai 10 biji epal, 2 tangan dan satu pisau. Dalam kehidupan, anda secara konsisten membersihkan keseluruhan sepuluh, dipandu oleh algoritma yang sama. Bagaimanakah anda boleh membuat program melakukan tindakan berulang dengan setiap epal?
  • Marilah kita mengikat diri kita dengan bilangan epal, tetapi jika kita mempunyai sedikit daripada mereka, beberapa arahan akan dilaksanakan dengan sia-sia tanpa "muatan" (dan, mungkin, kita akan memotong diri kita semasa mengupas epal yang tidak wujud).
  • Jika terdapat lebih banyak epal daripada pasukan pemprosesan kami, sesetengah produk tidak akan diproses.
  • "Kod" sedemikian sukar dibaca, mengandungi banyak pengulangan, dan sukar untuk diubah suai.

Gelung ialah pengendali untuk melakukan tindakan beberapa kali.

Java while loop (vile loop) berfungsi dengan baik dalam kes kami. Reka bentuk ini mengatur pelbagai tindakan ke dalam struktur yang ringkas dan mudah difahami. Algoritma sementara untuk menghiris epal untuk pai di Jawa mungkin kelihatan seperti ini:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');

Sintaks Perintah

Cara pertama untuk menerangkan pernyataan while adalah seperti berikut:
while(Логическое выражение) {
	// Loop body - periodically executed statement(s)
}
Ini dilakukan seperti berikut (langkah demi langkah):
  1. Kami menilai keadaan Boolean yang mengikuti semasa dalam kurungan.
  2. Jika keadaan logik adalah benar, maka pernyataan dalam badan gelung dilaksanakan, selepas melaksanakan pernyataan terakhir dalam badan gelung, pergi ke langkah 1
  3. Jika keadaan logik adalah palsu, maka kita pergi ke pernyataan pertama di luar gelung while.

Gelung dengan prasyarat

Memandangkan sebelum melaksanakan badan gelung, kami sentiasa mengira ungkapan logik (syarat untuk memasuki gelung), sementara jenis ini sering dipanggil gelung dengan prasyarat. Mari kita bina jadual sepuluh integer pertama, kuasa positif nombor:
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++;
    }
}
Hasil keluaran konsol:
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

Gelung dengan postcondition

Jenis kitaran kedua:
do {
    // Loop body - periodically executed statement(s)
}while (Логическое выражение);
Dilakukan seperti berikut (langkah):
  1. Badan gelung dilaksanakan (sejurus selepas kata kunci do).
  2. Kami menilai keadaan Boolean yang mengikuti semasa dalam kurungan.
  3. Jika keadaan logik adalah benar, kemudian pergi ke langkah 1
  4. Jika keadaan logik adalah palsu, maka kita pergi ke pernyataan pertama di luar gelung while.
Dua perbezaan utama daripada jenis gelung sebelumnya: badan gelung dilaksanakan sekurang-kurangnya sekali dan keadaan logik disemak selepas badan gelung dilaksanakan. Oleh itu, jenis gelung while ini dipanggil gelung postcondition. Kali ini kami akan memaparkan jadual kuasa nombor tidak melebihi 10000:
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
Hasil keluaran konsol:
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
Beri perhatian kepada perubahan dalam kod, membandingkannya dengan versi gelung dengan prasyarat.

Fakta menarik tentang bekerja dengan gelung

Perintah kawalan dalam badan gelung

Terdapat dua arahan yang mempengaruhi kemajuan gelung: putus, ciri yang akan kami tunjukkan dalam bab seterusnya, dan teruskan.
  • teruskan – menghentikan pelaksanaan badan gelung semasa dan bergerak ke ungkapan logik operator sementara. Jika ungkapan yang dikira adalah benar, pelaksanaan gelung akan diteruskan.
  • putus – segera menghentikan pelaksanaan gelung semasa dan melompat ke arahan pertama di luarnya. Oleh itu, pelaksanaan gelung semasa terganggu. Kami akan melihatnya dengan lebih terperinci dalam topik seterusnya.
Mari kita ingat contoh buah kita. Jika kami tidak pasti tentang kualiti epal yang ditawarkan, kami boleh menukar kod menggunakan arahan 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
    }
    положитьВПирог(яблоко.чистить().нарезать());
}
Pembinaan continuesering digunakan apabila dalam badan gelung adalah perlu untuk melaksanakan arahan apabila keadaan tertentu berlaku, sebagai contoh, untuk melakukan tindakan apabila sensor dalam peralatan dicetuskan (jika tidak, teruskan kitaran membaca penunjuknya) atau untuk mengira ungkapan hanya pada langkah-langkah tertentu kitaran. Contoh untuk kes terakhir ialah pengiraan dalam gelung sementara jumlah kubus nombor asli yang kuasa duanya kurang daripada nombornya:
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
}

Kitaran yang tidak berkesudahan

Arahan kawalan ini paling kerap digunakan dalam gelung tak terhingga. Ia dipanggil ini kerana keadaan keluar logik tidak pernah berpuas hati. Dalam kod ia kelihatan seperti:
while(true) {
    // Loop body
}
breakDalam kes ini, menggunakan arahan untuk mengatur keluar daripadanya akan berguna . Gelung jenis ini berlaku apabila menunggu keadaan luaran yang terbentuk di luar logik badan gelung. Sebagai contoh, dalam permainan yang meniru dunia maya di sekeliling wira (keluar dari gelung = keluar dari permainan), sistem pengendalian. Atau apabila menggunakan algoritma, mungkin menambah baik hasil dengan setiap panggilan berikutnya dalam gelung, tetapi mengehadkannya mengikut masa atau kejadian peristiwa luaran (dam, catur atau ramalan cuaca). Perlu diingat bahawa dalam keadaan biasa, gelung tidak berkesudahan adalah salah satu masalah ketidakstabilan program. Untuk menunjukkan, mari kembali kepada kuasa nombor:
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
    }
}
Hasil keluaran konsol:
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

Gelung Bersarang

Di sini kita sampai ke topik terakhir tentang kitaran kita. Mari kita fikirkan tentang pai epal (semoga anda tidak lapar pada masa ini) dan "gelung" kami:
  1. Jika terdapat epal dalam besen, ikut langkah 1.1 hingga 1.4:

    1. 1.1. Ambil sebiji epal
    2. 1.2. Bersihkan dan potong menjadi kepingan
    3. 1.3. Letakkan di atas dasar pai pastri dalam kuali
    4. 1.4. Mari kita kembali ke langkah 1.
Mari kita terangkan proses pemotongan menjadi kepingan dengan lebih terperinci:
  1. Bilangan kepingan = 0
  2. Walaupun bilangan kepingan adalah < 12, ikut langkah 2.1 hingga 2.3

    1. 2.1. Potong satu lagi kepingan dari epal
    2. 2.2. Bilangan kepingan ++
    3. 2.3. Kembali ke langkah 2
Dan masukkannya ke dalam algoritma kuih-muih kami:
  1. Jika terdapat epal di dalam besen, maka ikuti langkah 1.1 hingga 1.6:

    1. 1.1. Ambil sebiji epal
    2. 1.2. Kupas ia
    3. 1.3. Bilangan kepingan = 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-х видели на обложках тетрадей в младших классах.
Operator sementara - 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, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.
Komen
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION