Buclele în programare permit unui set de instrucțiuni să ruleze de mai multe ori în funcție de o condiție. În Java există trei tipuri de bucle, care sunt explicate mai jos:

1. pentru buclă

Bucla for este folosită atunci când știm numărul de iterații (știm de câte ori vrem să repetăm ​​o sarcină). Instrucțiunea for include condiția de inițializare și creșterea/descreșterea într-o linie. 

Exemplu: Programul Java de mai jos demonstrează o buclă for care tipărește numere de la 0 la 10 într-o singură linie.

// Java program to demonstrates the working of for loop import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i <= 10; i++) {  System.out.print(i + ' ');  }  } } 

0 1 2 3 4 5 6 7 8 9 10 

Sintaxă:

pentru (inițializare; condiție; creștere/scădere) {

// cod de executat

}

Imaginea de mai jos demonstrează diagrama fluxului unei bucle for:

• 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ă locală numai pentru buclă.
• Condiție de testare: Este folosit pentru a testa condiția de ieșire pentru o buclă. Trebuie să returneze o valoare booleană. Este, de asemenea, o buclă de control al intrării, deoarece condiția este verificată înainte de execuția instrucțiunilor buclei.
• Executarea declarației : Odată ce condiția este evaluată la adevărat, instrucțiunile din corpul buclei sunt executate.
• Crește/Decrementează : este folosit pentru actualizarea variabilei pentru următoarea iterație.
• Terminare buclă : Când condiția devine falsă, bucla se termină marcând sfârșitul ciclului său de viață.

Nota : Există o altă formă a buclei for cunoscută ca Îmbunătățit pentru buclă sau (pentru fiecare buclă).

zeenat aman actor

Bucla for îmbunătățită (pentru fiecare)

Această buclă este folosită pentru a repeta peste matrice sau colecții.

Exemplu : Programul Java de mai jos demonstrează o buclă for îmbunătățită (pentru fiecare buclă) pentru a itera printr-o matrice și a tipări numele.

// Java program to demonstrate  // the working of for each loop import java.io.*; class Geeks {  public static void main(String[] args)  {  String[] names = { 'Sweta' 'Gudly' 'Amiya' };  for (String name : names) {  System.out.println('Name: ' + name);  }  } } 

Name: Sweta Name: Gudly Name: Amiya 

Sintaxă:

pentru (variabila DataType : arrayOrCollection) {

// cod de executat

}

2. while Loop

O buclă while este folosită atunci când dorim să verificăm condiția înainte de a executa corpul buclei.

Exemplu: Programul Java de mai jos demonstrează o buclă while care tipărește numere de la 0 la 10 într-o singură linie.

// Java program to demonstrates  // the working of while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  int i = 0;  while (i <= 10) {  System.out.print(i + ' ');  i++;  }  } } 

0 1 2 3 4 5 6 7 8 9 10 

Sintaxă:

în timp ce (condiție) {

// cod de executat

}

Imaginea de mai jos demonstrează diagrama fluxului unei bucle while:

ce este stupul

• 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ță.

3. do-while Loop

Bucla do-while asigură executarea blocului de cod măcar o dată înainte de a verifica starea.

Exemplu : Programul Java de mai jos demonstrează o buclă do-while care tipărește numere de la 0 la 10 într-o singură linie.

// Java program to demonstrates  // the working of do-while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  int i = 0;  do {  System.out.print(i + ' ');  i++;  } while (i <= 10);  } } 

0 1 2 3 4 5 6 7 8 9 10 

Sintaxă:

face {

// cod de executat

} în timp ce (condiție);

Imaginea de mai jos demonstrează diagrama fluxului unei bucle do-while:

• bucla do while începe cu execuția instrucțiunii. 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, următoarea iterație a buclei începe.
• 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.

Greșeli frecvente în buclă și cum să le evitați

Dacă buclele nu sunt utilizate corect, acestea pot introduce capcane și erori care afectează lizibilitatea și funcționalitatea performanței codului. Mai jos sunt câteva capcane comune ale buclelor:

1. Bucle infinite

Aceasta este 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.

Tipuri de bucle infinite:

• infinit pentru Loop
• infinit while Loop

Exemplu: Aici ambele exemple demonstrează buclele infinite.

// Java program to demonstrate  // the infinite for loop import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 5; i--) {  System.out.println(  'This loop will run forever');  }  } } 

// Java Program to demonstrate  // the infinite while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  while(true)  {  System.out.println(  'Basic example of infinte loop');  }  } } 

Ieșire: Când rulați ambele coduri de mai sus, veți obține o eroare TLE (Time Limit Exceeded).

2. Erori off-by-One

Erorile Off-by-One sunt cauzate atunci când bucla rulează o dată mai mult sau o dată mai puțin decât ați dorit. Practic, se întâmplă atunci când condiția buclei nu este setată corect.

Exemplu : Programul Java de mai jos demonstrează o eroare Off-by-One în care bucla rulează de 6 ori și ne așteptam să ruleze de 5 ori.

// Java Program to demonstrates Off-by-One Errors import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i <= 5; i++) {  System.out.print(i + ' ');  }  } } 

3. Modificarea variabilelor buclei în interiorul buclei

Când schimbăm condiția buclei (cum ar fi i) în interiorul buclei, aceasta poate face ca bucla să sară peste anumite iterații sau să se comporte în moduri la care nu ne așteptam. Acest lucru poate duce la erori sau la un comportament neașteptat.

Exemplu : Programul Java de mai jos demonstrează modificarea variabilei buclei în interiorul buclei, ceea ce face ca bucla să sară peste anumite iterații și să se comporte neașteptat.

// Java program demonstrates  // modification in i variable import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 5; i++) {  if (i == 2) {    // Modifies the loop variable and skips  // the next iteration  i++;  }  System.out.println(i);  }  } } 

4. Goliți corpul buclei

Un corp de buclă gol apare atunci când o buclă este scrisă pentru a itera, dar nu efectuează nicio operație în interiorul buclei. Rularea unei bucle fără operațiuni utile în interiorul acesteia poate fi confuză.

Exemplu: Programul Java de mai jos demonstrează Corpul buclei goale.

// Java program to demonstrates Empty loop body import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 10; i++) {    // Empty body no operations  }  } } 

Nu va fi generată nicio ieșire pentru aceasta deoarece corpul buclei este gol.

Tabel Rezumat

Postări înrudite:

• pentru buclă
• buclă while
• bucla do-while