CodeGym /Blog Java /Aleatoriu /Declarația While
John Squirrels
Nivel
San Francisco

Declarația While

Publicat în grup
Primele noastre programe au fost o secvență de instrucțiuni care sunt executate una după alta. Fara furculite. Aceasta include HelloWorld, care afișează un salut. Include calcule aritmetice. După primele noastre programe, am învățat cum să ramificăm, adică cum să facem ca un program să efectueze diferite acțiuni în funcție de condițiile specifice. Iată codul pentru controlul unui sistem central de încălzire și aer condiționat:

if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort)
    heaterOn();
Fă următorul pas. În viața de zi cu zi, efectuăm adesea acțiuni repetitive uniforme, de exemplu, curățarea merelor pentru o plăcintă. Acest proces fascinant poate fi descris astfel:
  1. Dacă în castron sunt mere, atunci executăm pașii de la 1.1 la 1.4:

    1. 1.1. Luați un măr
    2. 1.2. Curățați-l și tăiați-l în felii
    3. 1.3. Aranjați feliile de mere în crusta de plăcintă într-o tigaie
    4. 1.4. Reveniți la pasul 1.
Declarația while - 2Să presupunem că ai zece mere, două mâini și un cuțit. În viața reală, decojești secvenţial toată duzina, urmând același algoritm pentru fiecare măr. Dar cum facem ca un program să facă o acțiune repetitivă pentru fiecare măr?
  • Ne legăm de numărul de mere, dar dacă nu avem suficiente, atunci unele comenzi ar fi executate fără „sarcină utilă” (și s-ar putea să ne tăiem în timp ce încercăm să curățăm un măr inexistent).
  • Dacă există mai multe mere decât comenzi de curățat, atunci unele dintre mere ar fi lăsate nedecojite.
  • Un astfel de cod este greu de citit. Are multe repetări și este greu de modificat.

Buclele sunt instrucțiuni care permit acțiunile să fie efectuate în mod repetat

Bucla while a Java va funcționa bine în cazul nostru. Acest construct pune mai multe acțiuni într-o structură concisă și ușor de înțeles. Folosind o buclă while , un algoritm de tăiere a mărului pentru o plăcintă ar putea arăta astfel în Java:

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    arrangeInPie(apple.peel().slice());
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");

Sintaxa comenzii

Prima variantă a declarației while este astfel:

while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}
Iată o explicație pas cu pas a ceea ce se întâmplă atunci când acest cod este executat:
  1. Evaluăm expresia booleană găsită în paranteze după cuvântul cheie while .
  2. Dacă expresia booleană este evaluată la adevărat, atunci instrucțiunile din corpul buclei sunt executate. După ce ultima instrucțiune din corpul buclei este executată, trecem la pasul 1
  3. Dacă expresia booleană este falsă, atunci sărim la prima instrucțiune după bucla while .

Buclă cu o condiție prealabilă

Deoarece evaluăm întotdeauna expresia booleană (condiția de intrare în buclă) înainte de a executa corpul buclei, această formă a buclei while este adesea numită buclă cu o precondiție . Să construim un tabel cu primele zece puteri ale unui număr:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (exponent <= 10) { // The condition for entering the loop
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
    }
}
Ieșire din consolă:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Buclă cu o postcondiție

Iată a doua variantă a acestei bucle:

do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
Iată o explicație a ceea ce se întâmplă atunci când acest cod este executat:
  1. Corpul buclei este executat (imediat după cuvântul cheie do ).
  2. Evaluăm expresia booleană găsită în paranteze după cuvântul cheie while .
  3. Dacă expresia booleană se evaluează la adevărat, atunci trecem la pasul 1
  4. Dacă expresia booleană este falsă, atunci sărim la prima instrucțiune după bucla while .
Cele două diferențe principale față de bucla anterioară sunt: ​​1) corpul buclei este executat cel puțin o dată și 2) expresia booleană este evaluată după ce corpul buclei este executat. În consecință, acest tip de buclă while se numește buclă cu o postcondiție . De data aceasta vom afișa un tabel cu puteri ale unui număr care nu depășește 10000:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = base; // The result of exponentiation
    int exponent = 1; // The initial exponent
    do {
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        result = result * base;
    } while (result < 10000); // The condition for exiting the loop
}
Ieșire din consolă:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
Atenție la modificările din cod. Comparați acest lucru cu bucla cu o precondiție.

Fapte interesante despre lucrul cu bucle

Declarații de ramificare în corpul buclei

Există două instrucțiuni care afectează execuția în cadrul unei bucle: break (pe care o vom discuta mai detaliat în capitolul următor) și continua.
  • continue — omite execuția restului corpului buclei în iterația curentă și trece la evaluarea expresiei booleene a instrucțiunii while. Dacă expresia se evaluează la adevărat, atunci bucla continuă.
  • break — încheie imediat execuția iterației curente și transferă controlul primei instrucțiuni după buclă. Astfel, această instrucțiune încheie execuția buclei curente. O vom analiza mai detaliat în articolul următor.
Amintiți-vă de exemplul nostru de fructe. Dacă nu suntem siguri de calitatea merelor, am putea schimba codul folosind o declarație continue :

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
    if (apple.isBad()) { // This method returns true for rotten apples
        apple.throwInGarbage();
        continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
    }
    arrangeInPie(apple.peel().slice());
}
Instrucțiunea continue este adesea folosită atunci când instrucțiunile din corpul buclei trebuie să fie executate dacă o anumită condiție este îndeplinită. De exemplu, putem dori să efectuăm acțiuni atunci când un senzor hardware este declanșat (în caz contrar, pur și simplu continuăm bucla în care luăm citirile senzorului) sau putem dori să calculăm o expresie numai pe anumite iterații ale unei bucle. Un exemplu al acestui ultim caz poate fi văzut în folosirea unei bucle while pentru a calcula suma cuburilor numerelor naturale al căror pătrat este mai mic decât numărul de numere. Confuz? Consultați următorul cod:

public static void main(String[] args) {
    int sum = 0;  // Total amount
    int i = 0;  // Initial number in the series
    int count = 20;  // Number of numbers
    while (i <= count) {
        i++;  // Get the next number — "i++" is equivalent to "i = i + 1"
        if (i * i <= count)  // If the square of the number is less than
            continue;  // the number of numbers, then we won't calculate the sum
                            // Jump to the next number in the loop
        sum += i * i * i;  // Otherwise, we calculate the sum of the cubes of numbers
    }  // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
    System.out.println(sum);  // Print the result
}

Buclă infinită

Aceste instrucțiuni de ramificare sunt folosite cel mai adesea în bucle infinite. Numim o buclă infinită dacă condiția booleană pentru ieșirea din buclă nu este niciodată îndeplinită. În cod, arată cam așa:

while (true) {
    // Loop body 
}
În acest caz, o instrucțiune break ne ajută să ieșim din buclă. Acest tip de buclă este potrivit atunci când se așteaptă condiții externe determinate în afara corpului buclei. De exemplu, în sisteme de operare sau jocuri (a ieși din buclă înseamnă a părăsi jocul). Sau când se utilizează algoritmi care încearcă, cu fiecare iterație a unei bucle, să îmbunătățească un rezultat, dar limitează numărul de iterații în funcție de timpul scurs sau de apariția unui eveniment extern (de exemplu, dame, șah sau prognoza meteo). Amintiți-vă că în condiții normale bucle infinite nu sunt de dorit. Pentru a demonstra, să revenim la exponențiere:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (true) {
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        if (exponent > 10)
            break; // Exit the loop
    }
}
Ieșire din consolă:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Bucle imbricate

Și acum ajungem la subiectul nostru final despre bucle. Amintiți-vă de acea plăcintă cu mere (sper că nu vă este foame în acest moment) și bucla noastră de curățare a merelor:
  1. Dacă în castron sunt mere, atunci executăm pașii de la 1.1 la 1.4:

    1. 1.1. Luați un măr
    2. 1.2. Curățați-l și tăiați-l în felii
    3. 1.3. Aranjați feliile de mere în crusta de plăcintă într-o tigaie
    4. 1.4. Reveniți la pasul 1.
Să descriem procesul de tăiere mai detaliat:
  1. Numărul de felii = 0
  2. Atâta timp cât numărul de felii este < 12, atunci efectuați pașii de la 2.1 la 2.3

    1. 2.1. Tăiați o altă felie din măr
    2. 2.2. Numărul de felii++
    3. 2.3. Reveniți la pasul 2
Și vom adăuga acest lucru la algoritmul nostru de preparare a plăcintei:
  1. Dacă în castron sunt mere, atunci executăm pașii de la 1.1 la 1.6:

    1. 1.1. Luați un măr
    2. 1.2. Curățați-l
    3. 1.3. Numărul de felii = 0
    4. 1.4. Atâta timp cât numărul de felii este < 12, atunci efectuați pașii de la 1.4.1 la 1.4.3
      1. 1.4.1. Tăiați o altă felie din măr
      2. 1.4.2. Numărul de felii++
      3. 1.4.3. Reveniți la pasul 1.4
    5. 1.5. Aranjați feliile de mere în crusta de plăcintă într-o tigaie
    6. 1.6. Reveniți la pasul 1.
Acum avem o buclă într-o buclă. Construcții ca acesta sunt foarte frecvente. Ca exemplu final, să construim una dintre tabelele de înmulțire pe care am învățat să le iubim în școala elementară.

 public static void main(String[] args) {
    // Print the second factors in a row
    System.out.println("    2  3  4  5  6  7  8  9"); 
    int i = 2;  // Assign the first factor to the variable
    while (i < 10) {  // First loop: execute as long as the first factor is less than 10
        System.out.print(i + " | ");  // Print the first factor at the beginning of the line
        int j = 2;  // The starting value of the second factor
        while (j < 10) { // Second loop: execute as long as the second factor is less than 10
            int product = i * j;  // Calculate the product of the factors
            if (product < 10)  // If the product is a single digit, then we print two spaces after the product
                System.out.print(product + "  ");
            else  // Otherwise, print the product and one space after it
                System.out.print(product + " ");
            j++;  // Increment the second factor by one
        }  // Go to the beginning of the second loop, i.e. "while (j < 10)"
        System.out.println();  // Move to the next line on the console
        i++;  // Increment the first factor by one
    } // Go to the beginning of the first loop, i.e. "while (i < 10)"
}
Ieșire din consolă:

    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
Buclele (în special, declarația while ) sunt unul dintre elementele fundamentale ale software-ului. Rezolvând sarcini pe CodeGym, veți învăța toate tipurile diferite de bucle, veți ajunge să înțelegeți complexitățile lor și veți dobândi abilități practice în utilizarea lor.
Comentarii
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION