pdf - e-book - archive - github.com

1.5  Boucles

Voir les diapos

Nous souhaitons créer un programme qui nous affiche tous les nombres de 1 à 5, donc dont l’exécution serait la suivante :

1 2 3 4 5

Une façon particulièrement vilaine de procéder serait d’ecrire 5 sysout successifs, avec la laideur des copier/coller que cela impliquerait. Nous allons étudier un moyen de coder ce type de programme avec un peu plus d’élégance.

1.5.1  Définitions et terminologie

Une boucle permet d’exécuter plusieurs fois de suite une même séquence d’instructions.

Cette ensemble d’instructions s’appelle le corps de la boucle. Chaque exécution du corps d’une boucle s’appelle une itération, ou plus informellement un passage dans la boucle. Lorsque l’on s’apprête à exécuter la première itération, on dit que l’on rentre dans la boucle, lorsque la dernière itération est terminée, on dit qu’on sort de la boucle.

Il existe trois types de boucle :

Chacune de ces boucles a ses avantages et ses inconvénients. Nous les passerons en revue ultérieurement.

1.5.2  while

En java, la boucle tant que se code de la façon suivante : 

while(<condition>)
{
  <instructions>
}

Les instructions du corps de la boucle sont délimitées par des accolades. La condition est évaluée avant chaque passage dans la boucle, à chaque fois qu’elle est vérifiée, on exécute les instructions de la boucle. Un fois que la condition n’est plus vérifiée, l’exécution se poursuit après l’accolade fermante.

Affichons par exemple tous les nombres de 1 à 5 dans l’ordre croissant, 

package boucles;

public class UnACinqTantQue
{
 public static void main(String[] args)
 {
  int i = 1;
  while (i <= 5)
  {
   System.out.print(i + " ");
   i++; 
  }
  System.out.println();
 }
}

Télécharger le fichier

Ce programme initialise i à 1 et tant que la valeur de i n’éxcède pas 5, cette valeur est affichée puis incrémentée. Les instructions se trouvant dans le corps de la boucle sont donc exécutées 5 fois de suite. La variable i s’appelle un compteur, on gère la boucle par incrémentations successives de i et on sort de la boucle une fois que i a atteint une certaine valeur. L’initialisation du compteur est très importante ! Si vous n’initialisez pas i explicitement, alors cette variable contiendra n’importe quelle valeur et votre programme ne se comportera pas du tout comme prévu. Notez bien qu’il n’y a pas de point-virgule après le while !

N’oubliez pas lorsqu’une boucle fonctionne avec un compteur :

1.5.3  do ... while

Voici la syntaxe de cette boucle : 

do
{
  <instructions>
}
while(<condition>);

Le fonctionnement est analogue à celui de la boucle tant que à quelques détails près :

En Java, la boucle répéter ... jusqu’à est en fait une boucle répéter ... tant que, c’est-à-dire une boucle tant que dans laquelle la condition est évaluée à la fin. Une boucle do ... while est donc exécutée donc au moins une fois. Reprennons l’exemple précédent avec une boucle do ... while : 

package boucles;

public class UnACinqRepeter
{
 public static void main(String[] args)
 {
  int i = 1;
  do
  {
   System.out.print(i + " ");
   i++; 
  }
  while (i <= 5);
  System.out.println();   
 }
}

Télécharger le fichier

De la même façon que pour la boucle while, le compteur est initialisé avant le premier passage dans la boucle. Un des usages les plus courant de la boucle do ... while est le contrôle de saisie : 

package boucles;

import java.util.Scanner;

public class ControleSaisieTantQue
{
 public static void main(String[] args)
 {
  Scanner saisie = new Scanner(System.in);
  int i;
  do
  {
   System.out.print("Saisissez un entier positif ou nul : ");
   i = saisie.nextInt();
   if (i < 0)
    System.out.println("J'ai dit positif ou nul !");
  }
  while (i < 0);
  saisie.close();
  System.out.println("Vous avez saisi " + i + ".");
 }

}

Télécharger le fichier

1.5.4  for

Cette boucle est quelque peu délicate. Commençons par donner sa syntaxe : 

for(<initialisation> ; <condition> ; <pas>)
{
  <instructions>
}

L’<initialisation> est une instruction exécutée avant le premier passage dans la boucle. La <condition> est évaluée avant chaque passage dans la boucle, si elle n’est pas vérifiée, on ne passe pas dans la boucle et l’exécution de la boucle pour est terminée. La <pas> est une instruction exécutée après chaque passage dans la boucle. On peut convertir une boucle for en boucle while en procédant de la sorte : 

<initialisation>
while(<condition>)
{
  <instructions>
  <pas>
}

On re-écrit l’affiche des 5 premiers entiers de la sorte en utilisant le fait que <initialisation> = i = 1, <condition> = i <= 5 et <pas> = i++. On obtient :

package boucles;

public class UnACinqPour
{
 public static void main(String[] args)
 {
  for (int i = 1; i <= 5 ;i++)
   System.out.print(i + " ");
  System.out.println(); 
 }

}

Télécharger le fichier

On utilise une boucle for lorsque l’on connait en entrant dans la boucle combien d’itérations devront être faites. Par exemple, n’utilisez pas une boucle pour pour contrôler une saisie !

1.5.5  Accolades superflues

De la même façon qu’il est possible de supprimer des accolades autour d’une instruction d’un bloc if, on peut supprimer les accolades autour du corps d’une boucle si elle ne contient qu’une seule instruction.