JavaRush /Java Blog /Random-TL /Habang ang Loop sa Java

Habang ang Loop sa Java

Nai-publish sa grupo

Panimula

Ang aming pinakaunang mga programa ay isang pagkakasunod-sunod ng mga tagubilin na sunod-sunod na isinagawa. Walang tinidor. Ito ang HelloWorld, na naglalabas ng isang parirala sa pagbati at mga kalkulasyon ng aritmetika sa console. Pagkatapos ng mga unang programa, natutunan namin ang sangay, iyon ay, ang programa ay nagsagawa ng ilang mga aksyon depende sa mga kondisyon. Narito kung paano mo mako-code ang air conditioner upang i-on para sa pagpainit at paglamig:
if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort
    heaterOn();
Gawin natin ang susunod na hakbang. Sa pang-araw-araw na buhay, madalas kaming nagsasagawa ng monotonous, paulit-ulit na mga aksyon, halimbawa, pagbabalat ng mga mansanas para sa isang pie. Ang kamangha-manghang prosesong ito ay maaaring ilarawan bilang:
  1. Kung may mga mansanas sa palanggana, sundin ang mga hakbang 1.1 hanggang 1.4:

    1. 1.1. Kumuha ng mansanas
    2. 1.2. Linisin at gupitin ito sa hiwa
    3. 1.3. Ilagay sa base ng pastry pie sa isang kawali
    4. 1.4. Bumalik tayo sa hakbang 1.
Operator habang - 2
Sabihin nating mayroon kang 10 mansanas, 2 kamay at isang kutsilyo. Sa buhay, palagi mong nililinis ang buong sampu, na ginagabayan ng parehong algorithm. Paano mo magagawa ang programa na gumawa ng paulit-ulit na aksyon sa bawat mansanas?
  • Itali natin ang ating sarili sa bilang ng mga mansanas, ngunit kung kakaunti tayo sa mga ito, ang ilan sa mga utos ay gagawin nang walang kabuluhan nang walang "payload" (at, marahil, puputulin natin ang ating sarili habang binabalatan ang isang hindi umiiral na mansanas).
  • Kung mas maraming mansanas kaysa sa aming mga team sa pagpoproseso, ang ilan sa mga produkto ay hindi mapoproseso.
  • Ang ganitong "code" ay mahirap basahin, naglalaman ng maraming pag-uulit, at mahirap baguhin.

Ang mga loop ay mga operator para sa pagsasagawa ng mga aksyon nang maraming beses.

Ang Java while loop (vile loop) ay gumagana nang maayos sa aming kaso. Ang disenyong ito ay nag-aayos ng maraming aksyon sa isang maigsi at naiintindihan na istraktura. Ang isang habang algorithm para sa paghiwa ng mga mansanas para sa isang pie sa Java ay maaaring magmukhang ganito:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');

Command Syntax

Ang unang paraan upang ilarawan ang habang pahayag ay ang mga sumusunod:
while(Логическое выражение) {
	// Loop body - periodically executed statement(s)
}
Ginagawa ito tulad ng sumusunod (hakbang-hakbang):
  1. Sinusuri namin ang kondisyon ng Boolean na sumusunod sa habang nasa panaklong.
  2. Kung totoo ang lohikal na kundisyon, ang mga operator sa loop body ay isasagawa, pagkatapos i-execute ang huling operator sa loop body, pumunta sa hakbang 1
  3. Kung mali ang lohikal na kundisyon, pupunta tayo sa unang pahayag sa labas ng while loop.

Loop na may precondition

Dahil bago isagawa ang katawan ng loop, palagi naming kinakalkula ang isang lohikal na expression (ang kundisyon para sa pagpasok sa loop), ang ganitong uri ng while ay madalas na tinatawag na loop na may precondition. Bumuo tayo ng talahanayan ng unang sampung integer, mga positibong kapangyarihan ng isang numero:
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++;
    }
}
Resulta ng output ng console:
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

Loop na may postcondition

Pangalawang uri ng cycle:
do {
    // Loop body - periodically executed statement(s)
}while (Логическое выражение);
Isinagawa bilang mga sumusunod (mga hakbang):
  1. Ang katawan ng loop ay isinasagawa (kaagad pagkatapos ng do keyword).
  2. Sinusuri namin ang kondisyon ng Boolean na sumusunod sa habang nasa panaklong.
  3. Kung totoo ang lohikal na kundisyon, pumunta sa hakbang 1
  4. Kung mali ang lohikal na kundisyon, pupunta tayo sa unang pahayag sa labas ng while loop.
Dalawang pangunahing pagkakaiba mula sa nakaraang uri ng loop: ang katawan ng loop ay naisakatuparan nang hindi bababa sa isang beses at ang lohikal na kondisyon ay nasuri pagkatapos na ang katawan ng loop ay naisakatuparan. Samakatuwid, ang ganitong uri ng while loop ay tinatawag na postcondition loop. Sa pagkakataong ito ay magpapakita kami ng talahanayan ng mga kapangyarihan ng isang numero na hindi hihigit sa 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
Resulta ng output ng console:
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
Bigyang-pansin ang mga pagbabago sa code, paghahambing nito sa bersyon ng loop na may precondition.

Mga kagiliw-giliw na katotohanan tungkol sa pagtatrabaho sa mga loop

Kontrolin ang mga utos sa katawan ng loop

Mayroong dalawang utos na nakakaapekto sa pag-usad ng loop: break, ang mga tampok na ipapakita namin sa susunod na kabanata, at magpatuloy.
  • magpatuloy – huminto sa pagpapatupad ng katawan ng kasalukuyang loop at lumipat sa lohikal na pagpapahayag ng habang operator. Kung totoo ang kinakalkula na expression, magpapatuloy ang pagpapatupad ng loop.
  • break - agad na huminto sa pagpapatupad ng kasalukuyang loop at tumalon sa unang command sa labas nito. Kaya, ang pagpapatupad ng kasalukuyang loop ay nagambala. Titingnan natin ito nang mas detalyado sa susunod na paksa.
Alalahanin natin ang ating halimbawa ng prutas. Kung hindi kami sigurado tungkol sa kalidad ng mga mansanas na inaalok, maaari naming baguhin ang code gamit ang command 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
    }
    положитьВПирог(яблоко.чистить().нарезать());
}
Ang konstruksiyon continueay kadalasang ginagamit kapag nasa katawan ng isang loop kinakailangan na magsagawa ng mga utos kapag naganap ang isang tiyak na kundisyon, halimbawa, upang magsagawa ng mga aksyon kapag ang isang sensor sa kagamitan ay na-trigger (kung hindi, ipagpatuloy lamang ang pag-ikot ng pagbabasa ng mga tagapagpahiwatig nito) o upang kalkulahin ang isang expression lamang sa ilang mga hakbang ng cycle. Ang isang halimbawa para sa huling kaso ay ang pagkalkula sa isang while loop ng kabuuan ng mga cube ng mga natural na numero na ang parisukat ay mas mababa sa kanilang numero:
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
}

Walang katapusang cycle

Ang mga control command na ito ay kadalasang ginagamit sa isang infinite loop. Ito ay tinatawag na ito dahil ang lohikal na kondisyon ng paglabas ay hindi kailanman nasisiyahan. Sa code, mukhang ganito:
while(true) {
    // Loop body
}
breakSa kasong ito, ang paggamit ng isang command upang ayusin ang isang paglabas mula dito ay magiging kapaki-pakinabang . Ang ganitong uri ng loop ay nangyayari kapag naghihintay para sa mga panlabas na kondisyon na nabuo sa labas ng lohika ng loop body. Halimbawa, sa mga laro na ginagaya ang virtual na mundo sa paligid ng bayani (paglabas sa loop = paglabas sa laro), mga operating system. O kapag gumagamit ng mga algorithm, marahil ay pinapabuti ang resulta sa bawat kasunod na tawag sa loop, ngunit nililimitahan ang mga ito sa pamamagitan ng oras o ang paglitaw ng isang panlabas na kaganapan (mga checker, chess o pagtataya ng panahon). Dapat alalahanin na sa ilalim ng normal na mga kondisyon, ang walang katapusang mga loop ay isa sa mga problema ng kawalang-tatag ng programa. Upang ipakita, bumalik tayo sa kapangyarihan ng mga numero:
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
    }
}
Resulta ng output ng console:
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

Nested Loops

Dito na tayo sa huling paksa tungkol sa ating mga cycle. Pag-isipan natin ang tungkol sa apple pie (sana hindi ka nagugutom sa ngayon) at ang aming "loop":
  1. Kung may mga mansanas sa palanggana, sundin ang mga hakbang 1.1 hanggang 1.4:

    1. 1.1. Kumuha ng mansanas
    2. 1.2. Linisin at gupitin ito sa hiwa
    3. 1.3. Ilagay sa base ng pastry pie sa isang kawali
    4. 1.4. Bumalik tayo sa hakbang 1.
Ilarawan natin ang proseso ng pagputol sa mga hiwa nang mas detalyado:
  1. Bilang ng mga hiwa = 0
  2. Habang ang bilang ng mga hiwa ay < 12, sundin ang mga hakbang 2.1 hanggang 2.3

    1. 2.1. Gupitin ang isa pang hiwa mula sa isang mansanas
    2. 2.2. Bilang ng mga hiwa ++
    3. 2.3. Bumalik sa hakbang 2
At ipasok ito sa aming algorithm ng confectionery:
  1. Kung may mga mansanas sa palanggana, sundin ang mga hakbang 1.1 hanggang 1.6:

    1. 1.1. Kumuha ng mansanas
    2. 1.2. Peel it off
    3. 1.3. Bilang ng mga hiwa = 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 habang - 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, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.
Mga komento
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION