Sløyfer i programmering lar et sett med instruksjoner kjøre flere ganger basert på en tilstand. I Java er det tre typer løkker som er forklart nedenfor:

1. for løkke

For-løkken brukes når vi vet antall iterasjoner (vi vet hvor mange ganger vi ønsker å gjenta en oppgave). For-setningen inkluderer initialiseringsbetingelsen og økning/redusering på én linje. 

Eksempel: Java-programmet nedenfor viser en for-løkke som skriver ut tall fra 0 til 10 på en enkelt linje.

   // 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  

Syntaks:

for (initialisering; betingelse; økning/redusering) {

// kode som skal kjøres

}

Bildet nedenfor viser flytskjemaet for en for-løkke:

• Initialiseringstilstand : Her initialiserer vi variabelen som er i bruk. Det markerer starten på en for-løkke. En allerede erklært variabel kan brukes eller en variabel kan kun erklæres lokal til loop.
• Testtilstand: Den brukes til å teste utgangstilstanden for en sløyfe. Den må returnere en boolsk verdi. Det er også en Entry Control Loop ettersom tilstanden kontrolleres før kjøringen av loop-setningene.
• Utførelse av erklæring : Når betingelsen er evaluert til å være sann, blir setningene i loop-kroppen utført.
• Øke/minske : Den brukes til å oppdatere variabelen for neste iterasjon.
• Sløyfeavslutning :Når tilstanden blir falsk, avsluttes løkken og markerer slutten på livssyklusen.

Note : Det er en annen form for for-løkken kjent som Forbedret for loop eller (for hver sløyfe).

Forbedret for loop (for hver)

Denne løkken brukes til å iterere over arrays eller samlinger.

Eksempel : Java-programmet nedenfor demonstrerer en Enhanced for loop (for hver loop) for å iterere gjennom en matrise og skrive ut navn.

   // 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  

Syntaks:

for (dataType-variabel: arrayOrCollection) {

// kode som skal kjøres

}

2. mens Loop

En while-løkke brukes når vi ønsker å sjekke tilstanden før vi utfører loop-kroppen.

Eksempel: Java-programmet nedenfor viser en while-løkke som skriver ut tall fra 0 til 10 på en enkelt linje.

   // 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  

Syntaks:

while (tilstand) {

// kode som skal kjøres

}

Bildet nedenfor viser flytskjemaet for en while-løkke:

• Mens loop starter med sjekk av boolsk tilstand. Hvis den ble evaluert til sann, kjøres loop body-setningene, ellers kjøres den første setningen etter loopen. Av denne grunn kalles det også Entry control loop
• Når betingelsen er evaluert til å være sann, blir setningene i loop-kroppen utført. Normalt inneholder setningene en oppdateringsverdi for variabelen som behandles for neste iterasjon.
• Når tilstanden blir usann, avsluttes løkken som markerer slutten på livssyklusen.

3. gjør-mens-løkke

Do-while-løkken sørger for at kodeblokken kjøres minst én gang før du sjekker tilstanden.

Eksempel : Java-programmet nedenfor viser en do-while-løkke som skriver ut tall fra 0 til 10 på en enkelt linje.

   // 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  

Syntaks:

gjør {

// kode som skal kjøres

} while (tilstand);

Bildet nedenfor viser flytskjemaet for en do-while-løkke:

• do while loop starter med utførelsen av setningen. Det er ingen kontroll av noen tilstand for første gang.
• Etter utførelsen av setningene og oppdateringen av variabelverdien kontrolleres betingelsen for sann eller usann verdi. Hvis den evalueres til sann, starter neste iterasjon av løkken.
• Når tilstanden blir usann, avsluttes løkken som markerer slutten på livssyklusen.
• Det er viktig å merke seg at do-while-sløyfen vil utføre setningene sine minst én gang før en hvilken som helst betingelse kontrolleres, og er derfor et eksempel på exit control loop.

Vanlige løkkefeil og hvordan du unngår dem

Hvis løkker ikke brukes riktig, kan de introdusere fallgruver og feil som påvirker kodeytelsens lesbarhet og funksjonalitet. Nedenfor er noen vanlige fallgruver med løkker:

1. Uendelige løkker

Dette er en av de vanligste feilene når du implementerer noen form for looping, er at den kanskje aldri avsluttes, det er at loopen kjører i uendelig tid. Dette skjer når tilstanden svikter av en eller annen grunn.

Typer uendelige løkker:

• uendelig for Loop
• uendelig mens Loop

Eksempel: Her demonstrerer begge eksemplene de uendelige løkkene.

   // 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'  );      }      }   }   

Produksjon: Når du kjører begge kodene ovenfor vil du få TLE (Time Limit Exceeded) feil.

2. Av-for-en-feil

Off-by-One-feil oppstår når sløyfen kjøres én eller flere ganger mindre enn du ønsket. Det skjer i utgangspunktet når sløyfetilstanden ikke er riktig satt.

Eksempel : Java-programmet nedenfor viser en Off-by-One-feil der løkken kjører 6 ganger og vi forventet at den skulle kjøre 5 ganger.

   // 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. Endre sløyfevariabler inne i sløyfen

Når vi endrer løkkebetingelsen (som i) inne i løkken kan det føre til at løkken hopper over visse iterasjoner eller oppfører seg på måter som vi ikke forventet. Dette kan føre til feil eller uventet oppførsel.

Eksempel : Java-programmet nedenfor demonstrerer modifisering av løkkevariabelen inne i løkken som får løkken til å hoppe over visse iterasjoner og oppføre seg uventet.

   // 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. Tøm sløyfekroppen

Et tomt sløyfelegeme oppstår når en løkke skrives for å iterere, men ikke utfører noen operasjoner inne i løkken. Å kjøre en løkke uten noen nyttige operasjoner inne i den kan være forvirrende.

Eksempel: Java-programmet nedenfor viser Empty loop body.

   // 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      }      }   }   

Ingen utgang vil bli generert for dette fordi hoveddelen av løkken er tom.

Sammendragstabell

Relaterte innlegg:

• for løkke
• mens loop
• gjør-mens-løkke