Buclă în limbaje de programare este o caracteristică care facilitează execuția unui set de instrucțiuni/funcții în mod repetat, în timp ce o anumită condiție se evaluează ca adevărată. Java oferă trei moduri de executare a buclelor. Deși toate modalitățile oferă funcționalități de bază similare, ele diferă în ceea ce privește sintaxa și timpul de verificare a condițiilor.
java oferă trei tipuri de instrucțiuni condiționale, acest al doilea tip este instrucțiunea buclă.
- bucla while: O buclă while este o instrucțiune de flux de control care permite ca codul să fie executat în mod repetat pe baza unei anumite condiții booleene. Bucla while poate fi gândită ca o declarație if care se repetă.
Sintaxa:
while (boolean condition) { loop statements... }> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >int> i=>0>;> >while> (i<=>10>)> >{> >System.out.println(i);> >i++;> >}> >}> }> |
>
>Ieșire
0 1 2 3 4 5 6 7 8 9 10>
- Diagramă:
- Bucla while începe cu verificarea condiției booleene. Dacă este evaluat la adevărat, atunci instrucțiunile buclei sunt executate, altfel prima instrucțiune care urmează buclei este executată. Din acest motiv se mai numește Bucla de control de intrare
- Odată ce condiția este evaluată la adevărat, instrucțiunile din corpul buclei sunt executate. În mod normal, instrucțiunile conțin o valoare de actualizare pentru variabila care este procesată pentru următoarea iterație.
- Când condiția devine falsă, bucla se termină, ceea ce marchează sfârșitul ciclului său de viață.
- pentru buclă: for loop oferă o modalitate concisă de scriere a structurii buclei. Spre deosebire de o buclă while, o instrucțiune for consumă inițializarea, condiția și creșterea/decrementarea într-o singură linie, oferind astfel o structură a buclei mai scurtă și ușor de depanat.
Sintaxă:
for (initialization condition; testing condition;increment/decrement) { statement(s) }> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >for> (>int> i=>0>;i<=>10>;i++)> >{> >System.out.println(i);> >}> >}> }> |
>
>Ieșire
0 1 2 3 4 5 6 7 8 9 10>
- Diagramă:
- Condiție de inițializare: Aici, inițializam variabila în uz. Acesta marchează începutul unei bucle for. O variabilă deja declarată poate fi utilizată sau o variabilă poate fi declarată, doar local pentru buclă. Condiție de testare: este folosit pentru testarea condiției de ieșire pentru o buclă. Trebuie să returneze o valoare booleană. Este, de asemenea, un Bucla de control de intrare întrucât condiția este verificată înainte de executarea instrucțiunilor buclei. Execuția instrucțiunilor: Odată ce condiția este evaluată la adevărat, instrucțiunile din corpul buclei sunt executate. Increment/Decrement: Este folosit pentru actualizarea variabilei pentru următoarea iterație. Terminarea buclei: Când condiția devine falsă, bucla se termină marcând sfârșitul ciclului său de viață.
- face în timp ce: bucla do while este similară cu bucla while cu doar diferența că verifică condiția după executarea instrucțiunilor și, prin urmare, este un exemplu de Ieșiți din bucla de control.
Sintaxă:
do { statements.. } while (condition);> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >int> i=>0>;> >do> >{> >System.out.println(i);> >i++;> >}>while>(i<=>10>);> >}> }> |
>
>Ieșire
0 1 2 3 4 5 6 7 8 9 10>
- Diagramă:
- bucla do while începe cu execuția instrucțiunilor. Nu se verifică nicio condiție pentru prima dată.
- După executarea instrucțiunilor și actualizarea valorii variabilei, condiția este verificată pentru valoarea adevărată sau falsă. Dacă este evaluat la adevărat, începe următoarea iterație a buclei.
- Când condiția devine falsă, bucla se termină, ceea ce marchează sfârșitul ciclului său de viață.
- Este important de reținut că bucla do-while își va executa instrucțiunile cel puțin o dată înainte ca orice condiție să fie verificată și, prin urmare, este un exemplu de buclă de control de ieșire.
Capcanele buclelor
- Buclă infinită: Una dintre cele mai frecvente greșeli în timpul implementării oricărui tip de buclă este că este posibil să nu iasă niciodată, adică bucla rulează pentru un timp infinit. Acest lucru se întâmplă atunci când starea eșuează dintr-un motiv oarecare. Exemple: bucla for infinită :
Java
lista java a
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >for> (;;) {> >}> >}> }> |
>
>
buclă while infinită:
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >while> (>true>)> >{> >// statement> >}> > >}> }> |
>
>
Java
//Java program to illustrate various pitfalls.> public> class> LooppitfallsDemo> {> >public> static> void> main(String[] args)> >{> >// infinite loop because condition is not apt> >// condition should have been i>0.> >for> (>int> i =>5>; i !=>0>; i -=>2>)> >{> >System.out.println(i);> >}> >int> x =>5>;> >// infinite loop because update statement> >// is not provided.> >while> (x ==>5>)> >{> >System.out.println('In the loop');> >}> >}> }> |
>
>
O altă capcană este că ați putea adăuga ceva în obiectul dvs. de colecție prin buclă și puteți rămâne fără memorie. Dacă încercați să executați programul de mai jos, după ceva timp, excepția din memorie va fi aruncată.
Java
//Java program for out of memory exception.> import> java.util.ArrayList;> public> class> Integer1> {> >public> static> void> main(String[] args)> >{> >ArrayList ar =>new> ArrayList();> >for> (>int> i =>0>; i { ar.add(i); } } }> |
>
>
Ieșire:
Exception in thread 'main' java.lang.OutOfMemoryError: Java heap space at java.util.Arrays.copyOf(Unknown Source) at java.util.Arrays.copyOf(Unknown Source) at java.util.ArrayList.grow(Unknown Source) at java.util.ArrayList.ensureCapacityInternal(Unknown Source) at java.util.ArrayList.add(Unknown Source) at article.Integer1.main(Integer1.java:9)>
Buclă imbricată:
Bucla imbricată înseamnă o instrucțiune de buclă în interiorul unei alte instrucțiuni de buclă.
Există diferite combinații de utilizare a buclei pentru buclă, in timp ce buclă, face în timp ce buclă.
Ex.1 Imbricat for bucla
Java
cum se returnează o matrice în java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >for>(>int> i =>0>; i <>3>; i++){> >for>(>int> j =>0>; j <>2>; j++){> >System.out.println(i);> >}> >System.out.println();> >}> >}> }> |
>
>Ieșire
0 0 1 1 2 2>
Ex.2 Bucla while imbricată
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> i =>1>, j =>1>;> >while> (i <=>3>) {> >while> (j <=>3>) {> >System.out.print(j);> >j++;> >}> >i++;> >System.out.println(>''>);> >j =>1>;> >}> >}> }> |
>
>Ieșire
123 123 123>
Ex.3 Bucla do while imbricată
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> row =>1>, column =>1>;> >int> x;> >do> {> >x =>4>;> >do> {> >System.out.print(>''>);> >x--;> >}>while> (x>= rând);> >column =>1>;> >do> {> >System.out.print(column +>' '>);> >column++;> >}>while> (column <=>5>);> >System.out.println(>' '>);> >row++;> >}>while> (row <=>5>);> >}> }> |
>
>Ieșire
1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5>
Ex.4 Bucla while și for imbricată
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> weeks =>3>;> >int> days =>7>;> >int> i =>1>;> >// outer loop> >while> (i <= weeks) {> >System.out.println(>'Week: '> + i);> >// inner loop> >for> (>int> j =>1>; j <= days; ++j) {> >System.out.println(>' Days: '> + j);> >}> >++i;> >}> >}> }> |
>
>Ieșire
Week: 1 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7 Week: 2 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7 Week: 3 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7>