Slingor i programmering gör att en uppsättning instruktioner kan köras flera gånger baserat på ett tillstånd. I Java finns det tre typer av loopar som förklaras nedan:

1. för slinga

For-loopen används när vi vet antalet iterationer (vi vet hur många gånger vi vill upprepa en uppgift). For-satsen inkluderar initialiseringsvillkoret och ökning/minskning på en rad. 

Exempel: Java-programmet nedan visar en for-loop som skriver ut nummer från 0 till 10 på en enda rad.

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

Syntax:

för (initiering; villkor; ökning/minskning) {

// kod som ska köras

}

Bilden nedan visar flödesschemat för en for-loop:

• Initieringsvillkor : Här initierar vi variabeln som används. Det markerar början på en for-loop. En redan deklarerad variabel kan användas eller en variabel kan endast deklareras lokal till loop.
• Testvillkor: Den används för att testa utgångsvillkoret för en slinga. Den måste returnera ett booleskt värde. Det är också en Entry Control Loop eftersom villkoret kontrolleras innan loop-satserna körs.
• Utlåtandeutförande : När villkoret har utvärderats till sant exekveras satserna i loopkroppen.
• Öka/minska : Den används för att uppdatera variabeln för nästa iteration.
• Slingavslutning :När villkoret blir falskt slutar slingan och markerar slutet på dess livscykel.

Notera : Det finns en annan form av for-slingan som kallas Förbättrad för loop eller (för varje slinga).

Förbättrad för loop (för varje)

Denna loop används för att iterera över arrayer eller samlingar.

Exempel : Java-programmet nedan visar en Enhanced for loop (för varje loop) för att iterera genom en array och skriva ut namn.

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

Syntax:

for (dataType variabel: arrayOrCollection) {

// kod som ska köras

}

2. medan Loop

En while-loop används när vi vill kontrollera villkoret innan vi kör loopkroppen.

Exempel: Java-programmet nedan visar en while-loop som skriver ut siffror från 0 till 10 på en enda rad.

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

Syntax:

while (villkor) {

// kod som ska köras

}

Bilden nedan visar flödesschemat för en while-loop:

• While loop börjar med kontrollen av booleskt tillstånd. Om det utvärderades till sant exekveras loopkroppssatserna annars exekveras den första satsen efter slingan. Av denna anledning kallas den också för ingångskontrollslinga
• När villkoret har utvärderats till sant exekveras satserna i loopkroppen. Normalt innehåller satserna ett uppdateringsvärde för variabeln som bearbetas för nästa iteration.
• När villkoret blir falskt avslutas slingan vilket markerar slutet på dess livscykel.

3. gör-under loop

Do-while-loopen säkerställer att kodblocket körs minst en gång innan du kontrollerar skicket.

Exempel : Java-programmet nedan visar en do-while loop som skriver ut siffror från 0 till 10 på en enda rad.

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

Syntax:

gör {

// kod som ska köras

} while (villkor);

Bilden nedan visar flödesschemat för en do-while loop:

• do while loop börjar med körningen av satsen. Det görs ingen kontroll av något tillstånd för första gången.
• Efter exekvering av satserna och uppdatering av variabelvärdet kontrolleras villkoret för sant eller falskt värde. Om den utvärderas till sann startar nästa iteration av loop.
• När villkoret blir falskt avslutas slingan vilket markerar slutet på dess livscykel.
• Det är viktigt att notera att do-while loopen kommer att exekvera sina uttalanden minst en gång innan något villkor kontrolleras och därför är ett exempel på exit control loop.

Vanliga loop-misstag och hur man undviker dem

Om loopar inte används på rätt sätt kan de introducera fallgropar och buggar som påverkar kodprestandan läsbarhet och funktionalitet. Nedan följer några vanliga fallgropar med loopar:

1. Oändliga loopar

Detta är ett av de vanligaste misstagen när man implementerar någon form av looping är att den kanske aldrig avslutas eftersom slingan körs i oändlig tid. Detta händer när tillståndet misslyckas av någon anledning.

Typer av oändliga loopar:

• oändlig för Loop
• oändlig medan Loop

Exempel: Här visar båda exemplen de oändliga slingorna.

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

Produktion: När du kör båda ovanstående koder får du ett TLE-fel (Time Limit Exceeded).

2. Av-för-ett-fel

Off-by-One-fel orsakas när slingan körs en gång mer eller en gång färre än du ville. Det händer i princip när loopvillkoret inte är korrekt inställt.

Exempel : Java-programmet nedan visar ett Off-by-One-fel där loopen körs 6 gånger och vi förväntade oss att den skulle köras 5 gånger.

   // 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. Ändra loopvariabler inuti loopen

När vi ändrar loopvillkoret (som i) inuti loopen kan det göra att loopen hoppar över vissa iterationer eller beter sig på ett sätt som vi inte förväntade oss. Detta kan leda till fel eller oväntat beteende.

Exempel : Java-programmet nedan visar modifiering av loopvariabeln inuti loopen vilket gör att loopen hoppar över vissa iterationer och beter sig oväntat.

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

En tom loopkropp uppstår när en loop skrivs för att iterera men inte utför några operationer inuti loopen. Att köra en loop utan några användbara operationer inuti den kan vara förvirrande.

Exempel: Java-programmet nedan visar 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 utdata kommer att genereras för detta eftersom huvuddelen av slingan är tom.

Sammanfattningstabell

Relaterade inlägg:

• för slinga
• medan loop
• gör-under loop