Les boucles de programmation permettent à un ensemble d’instructions de s’exécuter plusieurs fois en fonction d’une condition. En Java, il existe trois types de boucles qui sont expliquées ci-dessous :

1. pour la boucle

La boucle for est utilisée lorsque l’on connaît le nombre d’itérations (on sait combien de fois on souhaite répéter une tâche). L'instruction for inclut la condition d'initialisation et l'incrémentation/décrémentation sur une seule ligne. 

Exemple: Le programme Java ci-dessous montre une boucle for qui imprime les nombres de 0 à 10 sur une seule ligne.

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

Syntaxe:

pour (initialisation ; condition ; incrément/décrément) {

// code à exécuter

}

L'image ci-dessous montre l'organigramme d'une boucle for :

• Condition d'initialisation : Ici, nous initialisons la variable utilisée. Cela marque le début d’une boucle for. Une variable déjà déclarée peut être utilisée ou une variable peut être déclarée locale pour boucler uniquement.
• Conditions de test : Il est utilisé pour tester la condition de sortie d’une boucle. Il doit renvoyer une valeur booléenne. Il s'agit également d'une boucle de contrôle d'entrée car la condition est vérifiée avant l'exécution des instructions de boucle.
• Exécution de la déclaration : Une fois la condition évaluée à true, les instructions du corps de la boucle sont exécutées.
• Incrémenter/Décrémenter : Il est utilisé pour mettre à jour la variable pour la prochaine itération.
• Terminaison de boucle :Lorsque la condition devient fausse, la boucle se termine marquant la fin de son cycle de vie.

Note : Il existe une autre forme de boucle for connue sous le nom de Boucle for améliorée ou (pour chaque boucle).

Boucle for améliorée (pour chacun)

Cette boucle est utilisée pour parcourir des tableaux ou des collections.

Exemple : Le programme Java ci-dessous montre une boucle for améliorée (pour chaque boucle) pour parcourir un tableau et imprimer les noms.

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

Syntaxe:

pour (variable dataType : arrayOrCollection) {

// code à exécuter

}

2. while Boucle

Une boucle while est utilisée lorsque nous voulons vérifier la condition avant d'exécuter le corps de la boucle.

Exemple: Le programme Java ci-dessous montre une boucle while qui imprime les nombres de 0 à 10 sur une seule ligne.

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

Syntaxe:

tandis que (condition) {

// code à exécuter

}

L'image ci-dessous montre l'organigramme d'une boucle while :

• La boucle While commence par la vérification de la condition booléenne. S'il est évalué à vrai, les instructions du corps de la boucle sont exécutées, sinon la première instruction suivant la boucle est exécutée. Pour cette raison, on l'appelle également boucle de contrôle d'entrée.
• Une fois la condition évaluée à vrai, les instructions du corps de la boucle sont exécutées. Normalement, les instructions contiennent une valeur de mise à jour pour la variable en cours de traitement pour l'itération suivante.
• Lorsque la condition devient fausse, la boucle se termine, ce qui marque la fin de son cycle de vie.

3. faire en boucle

La boucle do-while garantit que le bloc de code s'exécute au moins une fois avant de vérifier l'état.

Exemple : Le programme Java ci-dessous montre une boucle do-while qui imprime les nombres de 0 à 10 sur une seule ligne.

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

Syntaxe:

faire {

// code à exécuter

} while (condition);

L'image ci-dessous montre l'organigramme d'une boucle do-while :

• la boucle do while commence par l'exécution de l'instruction. Aucune condition n’est vérifiée pour la première fois.
• Après l'exécution des instructions et la mise à jour de la valeur de la variable, la condition est vérifiée pour la valeur vraie ou fausse. S'il est évalué à vrai, la prochaine itération de la boucle démarre.
• Lorsque la condition devient fausse, la boucle se termine, ce qui marque la fin de son cycle de vie.
• Il est important de noter que la boucle do-while exécutera ses instructions au moins une fois avant qu'une condition ne soit vérifiée et constitue donc un exemple de boucle de contrôle de sortie.

Erreurs courantes de boucle et comment les éviter

Si les boucles ne sont pas utilisées correctement, elles peuvent introduire des pièges et des bugs qui affectent la lisibilité et la fonctionnalité du code. Vous trouverez ci-dessous quelques pièges courants liés aux boucles :

1. Boucles infinies

C'est l'une des erreurs les plus courantes lors de l'implémentation de tout type de boucle, c'est qu'elle peut ne jamais se terminer, c'est-à-dire que la boucle s'exécute pendant une durée infinie. Cela se produit lorsque la condition échoue pour une raison quelconque.

Types de boucles infinies :

• infini pour la boucle
• boucle while infinie

Exemple: Ici, les deux exemples démontrent les boucles infinies.

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

Sortir: Lorsque vous exécutez les deux codes ci-dessus, vous obtiendrez une erreur TLE (Time Limit Exceeded).

2. Erreurs ponctuelles

Des erreurs ponctuelles se produisent lorsque la boucle s'exécute une fois de plus ou de moins que vous le souhaitiez. Cela se produit essentiellement lorsque la condition de boucle n’est pas définie correctement.

Exemple : Le programme Java ci-dessous démontre une erreur Off-by-One où la boucle s'exécute 6 fois alors que nous nous attendions à ce qu'elle s'exécute 5 fois.

   // 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. Modification des variables de boucle à l'intérieur de la boucle

Lorsque nous modifions la condition de la boucle (comme i) à l'intérieur de la boucle, la boucle peut sauter certaines itérations ou se comporter d'une manière à laquelle nous ne nous attendions pas. Cela peut entraîner des erreurs ou un comportement inattendu.

Exemple : Le programme Java ci-dessous montre la modification de la variable de boucle à l'intérieur de la boucle, ce qui fait que la boucle saute certaines itérations et se comporte de manière inattendue.

   // 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. Corps de boucle vide

Un corps de boucle vide se produit lorsqu'une boucle est écrite pour itérer mais n'effectue aucune opération à l'intérieur de la boucle. Exécuter une boucle sans aucune opération utile à l’intérieur peut prêter à confusion.

Exemple: Le programme Java ci-dessous démontre le corps de la boucle vide.

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

Aucune sortie ne sera générée pour cela car le corps de la boucle est vide.

Tableau récapitulatif

Articles connexes :

• pour la boucle
• boucle while
• faire une boucle en attendant