Bucle Java: While și Do-While. Bucle For și while în Java
Când aveți nevoie de aceeași acțiune să fie efectuată de mai multe ori sau până când o anumită condiție este îndeplinită, buclele ne vin în ajutor.
Există mai multe moduri de a crea bucle în Java. După cum probabil ați ghicit, le vom lua în considerare pe toate.
Prima modalitate de a declara o buclă este să utilizați următorul construct: for (condiția de început a buclei; condiția de sfârșit; pasul la care va merge bucla) (corpul buclei)
Să trecem direct la exemple. Să presupunem că avem o sarcină de a afișa expresia „bună lume” de 10 ori. Dacă nu folosiți bucle, puteți scrie doar System.out.println("Bună lume"); de zece ori și vom rezolva problema. Să folosim bucle în acest scop. Creați o nouă clasă și numiți-o, de exemplu, CuclesInJava. Acum declarați condiția buclei (să fie 0), condiția finală - 10 și pasul. Vom merge în trepte de unu. În corpul buclei, plasați linia System.out.println("Bună lume");
Iată un exemplu de cod:
Rezultatul acestui cod va fi 10 rânduri la rând din expresia „Bună lume!”
Ce zici de a scrie ceva mai complex. Pe cele de bază le-am învățat deja. Să le folosim.
Să scriem o aplicație simplă care va afișa o linie de avertizare de fiecare dată când un pas + o variabilă este egală cu 5. Sunt foarte prost la imaginație))
Mai întâi, să scriem un cod care va accepta ca intrare o variabilă introdusă din consolă. În articolul anterior, am dat un exemplu al acestui cod și am convenit ca apoi să explic cum funcționează și de unde a venit. Și acum îl vom folosi pur și simplu:
Apoi, trebuie să scrieți o buclă care va începe de la zero și va număra până la zece (ca în exemplul anterior). În corpul buclei vom scrie un operator condiționat care va verifica dacă această variabilă este egală cu 5 și dacă da, atunci vom scoate linia „OK”. Iată ce am primit:
import java.util.Scanner ;
clasa publica CuclesInJava(
variabilă int = scanner.nextInt(); // Vom ajunge la asta treptat și apoi va fi clar cum funcționează
pentru (int i = 1; i< 10 ; i++ ) {
int newVariable = i + variabilă;
dacă (variabilă nouă== 5) (
Nu a ieșit foarte complicat. Cu acest exemplu, am vrut să arăt cum puteți utiliza bucle cu ramuri împreună.
Următorul mod de a declara bucle este cu constructul: while(condiția este adevărată)(blocul de cod care urmează să fie executat). Acest design are o altă formă:
do (blocul de cod care urmează să fie executat) în timp ce (condiția este adevărată). Diferența dintre primul și al doilea este că al doilea execută o buclă, indiferent dacă condiția este adevărată sau nu. Vă puteți gândi singur: mai întâi executăm codul, apoi verificăm starea. Și chiar dacă condiția nu este adevărată, codul se va executa totuși o singură dată, la momentul în care în primul tip de construcție se verifică pentru prima dată condiția și până când este adevărată, codul nu se va executa.
Codul ar trebui să fie intuitiv. Cred că merită menționat că cu constructele while și do-while poți "buclă" program dacă condiția de ieșire din buclă nu este specificată sau specificată incorect. Privește exemplul de mai sus și gândește-te ce s-ar fi întâmplat dacă aș fi scris nu i—, ci i++; sau în loc de i>0, i<0. Моя программа никогда не вышла бы из цикла и продолжала бы выводить строку Hello world! до тех пор, пока не завис компьютер. Поэтому, будьте очень осторожными с циклами и всегда следите, чтобы из них Ваша программа могла выйти или закончить работу.
Ei bine, un exemplu cu do-while:
Pe aceasta, cred, putem termina articolul despre bucle în Java. După cum puteți vedea, desenele nu sunt foarte complexe, dar foarte utile. Ele vor fi deosebit de utile atunci când ne vom familiariza cu matrice și șiruri.
Trebuie să procesați multe de același tip de date? Trebuie să calculați o serie? Trebuie să înmulțiți matrice? Toate acestea și multe altele vă vor ajuta să finalizați ciclul! 🙂 Toate sistemele de calcul au fost proiectate inițial pentru a facilita prelucrarea datelor. Și este imposibil chiar să ne imaginăm procesarea unei cantități mari de date fără bucle.
În general, buclele din programare sunt de obicei împărțite în trei grupuri. Primul grup este ciclurile cu contor. În ele, corpul buclei este executat de un anumit număr de ori, specificat inițial de programator. O astfel de buclă va fi în mod necesar executată de un număr specificat de ori. Al doilea grup este ciclurile cu o precondiție. În ele, corpul buclei este executat numai după verificarea unei anumite condiții și va fi executat atâta timp cât această condiție este adevărată. Este posibil ca astfel de bucle să nu fie executate nici măcar o dată (dacă condiția este inițial falsă). Iar al treilea grup de cicluri sunt cicluri cu o postcondiție. În ele, corpul buclei este mai întâi executat, apoi este verificată condiția. Această buclă va fi executată cel puțin o dată.
Să începem cu o buclă cu un contor. În Java, aceasta este o buclă for; În general, se poate scrie după cum urmează:
Pentru (condiție de început; condiție de final; modificare) (corp buclă; )
Astfel, dacă vrem să facem o acțiune de 10 ori, atunci trebuie să scriem următoarele:
Pentru (int i = 0; i<10; i++) { System.out.println(i); }
un astfel de program va afișa secvenţial numere de la zero la nouă. Mai detaliat, pur și simplu creăm o nouă variabilă i și îi atribuim valoarea inițială 0 (int i = 0;). Apoi precizăm că bucla ar trebui să fie executată până la i< 10 и указываем каким образом должно изменяться i после каждой итерации цикла (i++).
Cei care au programat în Pascal vor fi încântați de această oportunitate:
Int k = 15; pentru (float i = 0; i În acest exemplu, valoarea variabilei i va crește cu 1,5 cu fiecare iterație. Poti sa verifici:). Următorul ciclu în linie - in timp ce. Aceasta este o buclă cu o precondiție și, în formă generală, poate fi scrisă astfel: While (expresie logică) ( acțiuni ) Ei bine, dacă luăm un exemplu de lucru, va arăta cam așa: In timp ce<10)
{
System.Out.Print(a);
a++;
}
Deci, este clar că această buclă are sens să o folosești dacă nu știi exact de câte iterații sunt necesare pentru a atinge obiectivul, dar știi exact condiția în care obiectivul tău va fi atins. O astfel de construcție nu poate fi executată nici măcar o dată (la urma urmei, aceasta este o buclă cu o precondiție)! De câte ori sunt executate acțiunile în buclă depinde de valoarea care a fost inițial în variabilă A. Iar al treilea tip de cicluri sunt ciclurile cu o postcondiție. El este foarte asemănător cu în timp ce... face numai dacă în în timp ce... face condiția este verificată înainte de a executa corpul buclei, aici condiția este verificată după ce este executat corpul buclei. Aceasta înseamnă că bucla va fi executată cel puțin o dată înainte ca condiția să fie verificată. O buclă este un bloc de comenzi care este executat din nou și din nou atâta timp cât este îndeplinită o anumită condiție. Piesa repetată de cod se numește „corpul buclei”. O execuție a corpului buclei se numește iterație. În Java, puteți lucra cu mai multe tipuri de bucle - pentru aceasta există următorii operatori: in timp ce– ciclul cu condiție prealabilă– mai întâi verificăm condiția, apoi executăm corpul buclei; face în timp ce– ciclul cu postcondiție– mai întâi executăm corpul buclei o dată, apoi verificăm condiția și, dacă este îndeplinită, continuăm; pentru– buclă cu un numărător – rulează și actualizează contorul la fiecare iterație atâta timp cât condiția din declarația buclei este îndeplinită (adică, verificarea condiției returnează adevărată); prescurtat pentru(cunoscut ca foreach în alte limbi) – iterează prin matrice de la primul element până la ultimul și execută corpul buclei la fiecare iterație. Esența condiției buclei este verificarea unei expresii cu una sau mai multe variabile: „În timp ce a<11, в каждой итерации выполняем тело цикла и увеличиваем "а" на 1». Но чему равно «а» при первом выполнении цикла? Dacă folosim constructe cu while, valoarea trebuie specificată înainte de începerea buclei: int a = 1; In timp ce< 11) {
System.out.println(a); a++; //mărește a cu unu
}
Dacă variabila funcționează ca un numărător de bucle și nu este utilizată în afara acesteia, este inițializată direct în condiție. Și apoi scriu ce să facă cu el la sfârșitul fiecărei iterații. Toate acestea - într-o singură linie - folosind pentru: pentru (a=1, a<11, i++) {
System.out.println(a);
}
Obținem același rezultat. Lista ar putea începe de la zero sau de la o valoare negativă - determinăm singuri intervalul. Versiunea scurtată a buclei for nu conține nicio indicație a numărului de repetări sau acțiuni la sfârșitul pasului. O buclă foreach este utilizată pentru a itera prin matrice. Trebuie să treceți de la primul element la următorul până la sfârșitul matricei. int ms = ( 1, 2, 3, 4); //creează o matrice
int s = 0;
for(int i: ms) ( //specificați ce să repetați
s *= i; //înmulțim constant elementele
}
Println(e) de.sistem;
Buclele pot fi imbricate una în alta. În acest caz, numărul de repetări ale buclelor exterioare și imbricate este înmulțit. Dacă cea exterioară urmează să fie executată de 5 ori și cea interioară de 5 ori, bucla va fi executată de 25 de ori în total. Să afișăm tabelul înmulțirii folosind două matrice: int a, b, rezultat = 0; pentru (a = 2; a< 10; a++) {
pentru (b = 2; b< 10; b++) {
rezultat = a*b; System.out.println(a+"x"+b+" = "+rezultat);
}
}
Buclele sunt utile atunci când trebuie să creați și să numerotați multe obiecte. Numărul acestora este uneori necunoscut dinainte: obiectele pot fi create la cererea utilizatorului. Așa că am întrebat cât de mult este nevoie de ceva și am scris numărul în variabila n. Acum să creăm obiecte în cantitatea necesară: Ceva matrice = nou Ceva[n]; //creează o matrice de tip „ceva” din n elemente
for(int i = 0; i< n; i++){
matrice[i] = nou Ceva(); //creați „ceva” și puneți-l într-o matrice
}
Pentru a ieși dintr-o buclă, există cuvintele cheie pauză - „întrerupere”, continuare - „reluare” și întoarcere - „întoarcere”. Comanda break comută programul pentru a executa instrucțiunile care urmează buclei. Condițiile de întrerupere a buclei în Java sunt formalizate prin ramificare if. Principalul lucru este că verificarea este efectuată înaintea părții principale a corpului buclei. //după crearea matricei m scriem:
pentru (a: m) ( dacă (a==5) rupe; System.out.println(a); }
Operatorii de ramificație și de buclă din Java lucrează adesea împreună: începem o buclă, iar în interiorul acesteia verificăm dacă nu a fost încă îndeplinită o condiție în care trebuie să întrerupem bucla sau să facem altceva. Dacă utilizați break într-o buclă imbricată, numai acea buclă va fi întreruptă, în timp ce bucla exterioară va continua să se execute. Pentru a termina o iterație a buclei for devreme în Java, se folosește continuare. Când programul ajunge la el, omite partea neterminată a iterației, actualizează contorul și trece la următoarea iterație. În constructele while, același continue funcționează diferit: ne întoarce la verificarea condiției pentru continuarea buclei. O altă comandă, return, returnează programul în locul în care a fost apelată metoda în care se află bucla. Atât continuare, cât și break pot fi folosite cu o etichetă - pentru a sări la partea dorită a codului - prin analogie cu goto: breakMark1; //cu condiția ca Mark1 să fie undeva deasupra:
Crearea unei bucle infinite este ușoară - doar nu specificați niciun parametru în for: pentru (; ;) () E mai greu să profiti de ea. De obicei, o buclă infinită este o eroare critică care împiedică executarea programului. Prin urmare, fiecare buclă ar trebui verificată pentru capacitatea sa de a se termina corect la momentul potrivit. Pentru a face acest lucru aveți nevoie de: În acest tutorial, vom învăța cum să reexecutăm părți ale codului nostru într-un mod controlat, analizând diferite tipuri de bucle în Java. Să aruncăm o privire mai atentă asupra ciclurilor: in timp ce, do-in timp ce, pentru. Vom încerca să stabilim în ce cazuri care ciclu este cel mai potrivit pentru utilizare. Apoi ne vom uita pe scurt la subiectul numerelor aleatoare ( Aleatoriunumere). Să ne uităm la Java-Clasă Aleatoriuși cum ne poate ajuta în jocul nostru. O buclă, după cum sugerează și numele, este o modalitate de a executa aceeași bucată de cod de câte ori este necesar (fără a repeta neapărat rezultatul executării codului în buclă). Numărul de repetări ale ciclului poate fi fie determinat în prealabil, fie necunoscut programatorului însuși. Ne vom uita la principalele tipuri de bucle pe care limbajul ni le oferă să le folosim. Java.Și apoi vom introduce unele dintre ele în jocul nostru, îmbunătățindu-l astfel. Ciclu in timp ce are cea mai simplă sintaxă. Tine minte dacă-instructiuni pe care le-am studiat putin mai devreme. În expresia condiționată a operatorului dacă(ceea ce este cuprins între paranteze după cuvânt dacă) puteți pune aproape orice combinație de operatori și variabile. Dacă expresia este adevărată ( Adevărat), apoi codul inclus în corpul blocului dacă va fi gata. La fel și în buclă in timp ce punem o expresie care poate fi evaluată în Adevărat sau fals așa cum se arată în acest cod: Int x = 10; while(x > 0)( x--; //x scade cu câte unul la fiecare trecere a buclei) Ce se petrece aici? Primul lucru în afara buclei in timp ce am declarat o variabilă X tip intși a atribuit valoarea „10” acestei variabile. Apoi începe ciclul in timp ce, in conditiile in care este scris “
x > 0”– aceasta înseamnă că codul scris în corpul buclei in timp ce va fi executat atâta timp cât variabila X Mai mult 0
iar condiția nu va atinge valoarea fals. Prin urmare, codul va fi executat de 10 ori(x=10,x>0; x=9,x>0; x=8,x>0; x=7,x>0; x=6,x>0; x=5 ,x>0 ; x=4,x>0 ; La prima trecere a ciclului x = 10, în al doilea deja 9
, în al treilea 8
etc. Și atunci când X va fi egal 0
, atunci condiția de intrare în buclă nu va fi îndeplinită, iar programul va continua de la următoarea linie după terminarea buclei. La fel ca la operator dacă, este posibilă o situație în care bucla să nu fie executată nici măcar o dată. Aruncă o privire la următorul exemplu: Int x = 10; while(x > 10)( //un cod //dar nu va fi executat niciodată când x este mai mare de 10) În plus, nu există nicio limită pentru complexitatea expresiei condiției sau cantitatea de cod care poate fi scris în corpul buclei: Int playerLives = 3; int alienShips = 10; while(playerLives >0 && alienShips >0)( //Tot codul jocului aici //... //... // etc. ) //programul va continua aici când playerLives sau alienShips = 0 Această buclă va rula până la oricare dintre variabile playerLives, sau alienships nu va fi egal sau mai mic de zero. De îndată ce apare una dintre aceste condiții, expresia din condiție va lua valoarea fals iar programul va continua de la linia următoare după finalizarea buclei. Este de remarcat faptul că, odată ce programul intră în corpul buclei, acesta va fi executat chiar dacă condiția buclei devine fals, undeva în corpul buclei, pentru că starea se verifică numai la intrare: Int x = 1; while(x > 0)( x--; //x este acum egal cu 0 și condiția data viitoare va fi falsă //Dar această linie va fi executată //Și aceasta //Și chiar aceasta) În exemplul de mai sus, corpul buclei va fi executat o dată. În plus, puteți seta o condiție astfel încât bucla să ruleze pentru totdeauna - aceasta se numește ciclu nesfârșit. Iată un exemplu: Int x = 0; în timp ce(adevărat)( x++; //Voi deveni foarte mare!) Ce se întâmplă dacă într-adevăr trebuie să folosim o buclă infinită, dar în așa fel încât să putem decide în ce punct să ieșim din ea. În acest scop în Java există un cuvânt cheie pauză. Putem folosi pauză când trebuie să „ieșim” din buclă: Int x = 0; în timp ce (adevărat)( x++; //Voi deveni foarte mare! pauză; //Nu, nu vei! //Codul de aici nu va fi atins) Cu siguranță ați ghicit deja că este posibil să combinați diverse instrumente de luare a deciziilor, precum dacă,altfel,intrerupatorîn bucla noastră in timp ceși alte cicluri, pe care le vom analiza mai jos. De exemplu: Int x = 0; int preaBig = 10; while(true)( x++; //Voi deveni foarte mare! if(x == tooBig)( break; //Nu, nu o vei face. ) //codul de aici va fi disponibil până când x este egal cu 10) Putem scrie mai multe variații diferite, dar pentru noi aplicarea practică a acestor cunoștințe este mai importantă, așa că nu vom aprofunda prea mult acum. Să ne uităm la un alt concept care poate fi manipulat într-o buclă. continua funcționează aproape la fel ca pauză. Cuvânt cheie continua vă va da afară din corpul buclei, dar apoi testați expresia condiției în loc să continuați de la acolada de închidere a buclei, așa cum s-ar întâmpla cu pauză. Următorul exemplu arată utilizarea continua: Int x = 0; int preaBig = 10; int tooBigToPrint = 5; while(true)( x++; //Voi deveni foarte mare! if(x == tooBig)( break; ) //Nu, nu o vei face. //Codul de aici va fi disponibil doar până când x este egal cu 10 if(x > = tooBigToPrint)( //nu va mai fi tipărit pe ecran, dar bucla va continua; ) //codul de aici va fi disponibil până când x este egal cu 5 //cod pentru a imprima x pe ecran ) Explicație: declarăm și inițializam variabile. Intrăm în buclă și adăugăm la valoarea variabilei X unitate (acum X= 1). Bifând „Este 1 egal cu 10?” — fals- primul operator dacă nu este executat. Următoarea verificare este „Este 1 mai mare sau egal cu 5?” — fals- al doilea operator dacă nu este executat. Noi ieșim X la ecran. Să luăm în considerare opțiunea când X va lua valoarea 5 la intrarea în buclă. Intrăm în buclă și adăugăm la valoarea variabilei X unitate (acum X= 6). Bifând „6 este egal cu 10?” — fals- primul operator dacă nu este executat. Următoarea verificare este „6 este mai mare sau egal cu 5?” — Adevărat- intrăm în corp dacă — continua, ieșiți din buclă și verificați condiția de intrare în buclă. Acum opțiunea este când X va lua valoarea 9 la intrarea în buclă. Intrăm în buclă și adăugăm la valoarea variabilei X unitate (acum X= 10). Bifând „Este 10 egal cu 10?” — Adevărat- intrăm în corp dacă — pauză, ieșiți din buclă și codul va continua dincolo de acolada de închidere a buclei in timp ce. Aproape la fel ca bucla anterioară, cu excepția unei caracteristici - verificarea execuției expresiei condiționate va avea loc după corpul buclei. Aceasta înseamnă că ciclul do-in timp ce va fi întotdeauna executat cel puțin o dată. Aruncă o privire la exemplu: Int x = 0; face ( x++; ) în timp ce (x< 10);
//x теперь = 10
Cuvinte cheie pauză,continua Ciclu pentru are o sintaxă mai complexă decât in timp ceȘi do-in timp ce, deoarece necesită puțin mai multă manipulare pentru a inițializa. Să ne uităm mai întâi la el și apoi să-l demontăm: Pentru(int i = 0; i< 10; i++){
//Что-то, что должно произойти 10 раз будет записано здесь
}
Cum vede compilatorul asta? Ca aceasta: For(declarare și inițializare; condiție; modificare după fiecare trecere a buclei)( // corpul buclei) Cuvinte cheie pauză,continua poate fi folosit și în acest ciclu. Ciclu pentru preia controlul asupra inițializării, testării condițiilor și modificării variabilelor. Să încercăm acest ciclu în practică în aplicația noastră imediat după ce ne familiarizăm cu numere aleatoriiȘi metode. O buclă Java While Do este o instrucțiune care vă permite să rulați aceeași bucată de cod de mai multe ori. Această buclă poate fi folosită pentru a repeta acțiuni atunci când sunt îndeplinite condițiile. Bucla while este cel mai simplu de construit în limbajul Java. Constă dintr-o cheie while, o condiție de buclă și un corp de buclă: while (condiție) ( // corpul buclei ) Fiecare rulare separată a corpului buclei este considerată o iterație. Înainte de fiecare iterație, condițiile buclei sunt evaluate. Corpul său este executat numai dacă condiția buclei este evaluată la true . Iterațiile buclei schimbă ceva și, la un anumit moment, evaluarea condiției returnează false , moment în care bucla se termină. O buclă a cărei condiție nu returnează niciodată false este executată de un număr infinit de ori. Astfel de cicluri sunt numite nesfârșite. Exemplu int num = 0; în timp ce (num< 10) {
System.out.println(num);
num++;
} Acest exemplu tipărește numerele de la 0 la 9. Să parcurgem codul pas cu pas. Mai întâi inițializam variabila num cu o valoare de 0. Acesta va fi contorul de bucle. Când programul ajunge la while , sunt evaluate condițiile buclei. În cazul nostru 0< 10
возвращает значение true
и исполняется тело цикла. Внутри цикла выводится переменная num
, а затем увеличивается на 1
. На этом завершается первая итерация. După prima „rulare”, condiția buclei Java While este evaluată a doua oară. 1< 10
по-прежнему возвращает true
, после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз. Iterația finală începe când valoarea lui num este egală cu 9 . Contorul buclei este afișat pentru ultima dată, iar valoarea este crescută la 10. De data aceasta, o nouă iterație nu poate fi începută deoarece condiția buclei este evaluată la false . Deoarece 10 nu este mai puțin de 10. Astfel, bucla rulează atâta timp cât condiția buclei este îndeplinită. Înarmat cu aceste cunoștințe, puteți crea bucle mai complexe și mai funcționale. Să repetăm matricea: Nume șiruri = ("Doc", "Dopey", "Bashful", "Grumpy", "Sneezy", "Sleepy", "Happy"); int index = 0; în timp ce (index< names.length) {
System.out.println(names);
index++;
} Conceptul acestui exemplu este similar cu cel anterior. Inițializam contorul de bucle și iterăm prin matrice până când toate elementele sunt tipărite. Ca rezultat, iterarea peste matrice este un caz destul de comun, iar Java are o construcție mai bună pentru aceasta: bucla For. Bucla Java while do este similară cu while , dar are o diferență semnificativă: spre deosebire de while , condiția este verificată la sfârșitul fiecărei iterații. Aceasta înseamnă că bucla do-while este întotdeauna executată cel puțin o dată: do ( // corpul buclei ) while (condiție); Exemplu do-while execută mai întâi corpul buclei și apoi evaluează condițiile acesteia. În funcție de rezultatul obținut, bucla se oprește sau începe următoarea iterație. Să ne uităm la un joc simplu „ghici numele”: Scanner scanner = scaner nou (System.in); Ghicirea șirului; do ( System.out.print("Ghicește numele: "); ghici = scanner.nextLine(); ) while (!"Daffy Duck".egals(ghici)); System.out.println("Felicitări! Mi-ai ghicit numele!"); Acest exemplu, în timp ce Java folosește Scanner pentru a analiza intrarea din system.ini. Acesta este canalul de intrare standard care interacționează cu tastatura în majoritatea cazurilor. Pur și simplu, citim pur și simplu textul pe care îl introduce jucătorul. În joc, trebuie să întrebi utilizatorul cel puțin o dată și să faci asta atâta timp cât jucătorul introduce răspunsurile corecte. Bucla do-while este ideală pentru astfel de cazuri. În corpul buclei, obținem valoarea utilizatorului și apoi verificăm corectitudinea răspunsului. Bucla ar trebui să ruleze până când valoarea introdusă de utilizator este egală cu Daffy Duck. Dacă se primește răspunsul corect, bucla se oprește și felicităm jucătorul pentru victoria sa. Această publicație este o traducere a articolului „ Buclele While și Do-While ale Java în cinci minute„, pregătit de echipa prietenoasă de proiectBucle imbricate Java
Crearea de obiecte într-o buclă Java
Cum să ieși dintr-o buclă Java
Buclă infinită Java
While Loop
Ieșirea ciclului lor. Cuvânt cheie pauză
Cuvânt cheie continua
bucla do-while
pentru buclă
for(int i = 10; i > 0; i--)( //numaratoare inversa ) //tasta de pornire, i = 0 While Loop
bucla do-while
În concluzie
Buclele Java while adevărate vă permit să reutilizați bucăți de cod de mai multe ori. Astăzi ni s-au prezentat buclele Java while și do-while. Ele sunt similare prin faptul că verifică condițiile și execută corpul buclei dacă condiția este evaluată la adevărat. Dar, în același timp, au o diferență semnificativă: starea buclei while este verificată înainte de iterație, iar starea buclei do-while este verificată la sfârșitul fiecărei iterații. Aceasta înseamnă că bucla do-while este întotdeauna executată cel puțin o dată.
