Apprenez à programmer en Java

Imaginez que vous ayez un bloc de code que vous devez répéter plusieurs fois. Pourquoi pas pour afficher un message dans la console, par exemple un bonjour, répété cinq fois ? Vous pouvez écrire cinq fois la commande pour le faire. Mais subitement, vous ne souhaitez plus dire “bonjour”, mais “bonjour à tous !”. Il faudrait alors modifier cinq fois le bloc dans votre code. Comme tout développeur vous le dira, nous détestons les répétitions (et sommes un peu fainéants !).

Et c’est pour cela que les boucles existent !

Utilisez des boucles énumérées pour un nombre connu d'itérations

Les boucles énumérées sont des boucles qui sont utilisées si vous savez à l'avance combien de fois vous voulez faire une boucle. En Java, cela s'appelle des boucles for.

Avec elles, vous pouvez indiquer le nombre d'itérations à effectuer :

1. En tant que valeur entière.

2. Comme résultat d'une expression qui génère une valeur entière.

Découvrez les boucles  for  avec une valeur entière

Voici un exemple d'une boucle for qui répète une instruction cinq fois :

for (int i=0; i<5;i++) {
   System.out.println("Clap your hands!");
}

Dans cet ensemble d'instructions, nous avons une variable de dénombrement   i  qui est responsable du nombre d'exécutions. Le code équivalent sans utiliser une boucle serait :

System.out.println("Clap your hands!");
System.out.println("Clap your hands!");
System.out.println("Clap your hands!");
System.out.println("Clap your hands!");
System.out.println("Clap your hands!");

La syntaxe générale de l'instruction for est la suivante :

for (initialisation; terminaison; increment) {
// code à répéter
}

1. L'initialisation est une expression qui s’initialise au début de la boucle. Elle déclare et assigne généralement un itérateur. Dans notre exemple, nous déclarons un itérateur nommé   i  de type   int  avec une valeur de   0  .

2. La terminaison est l’expression qui est évaluée avant chaque exécution de boucle. Si elle est évaluée sur « false », la boucle s'arrête. Dans notre exemple, l'expression de terminaison est   i<5  , ce qui signifie que la boucle s'arrête lorsque   i  atteint la valeur cinq.

3. L’incrément est une expression qui est évaluée chaque fois qu'une itération de la boucle est effectuée. Dans notre exemple, l'incrément est   i++  . Cela signifie que nous ajoutons 1 à la valeur de i à chaque fois que nous passons par notre boucle.

4. La liste des instructions est située entre   {  et   }  . C'est le code qui est exécuté chaque fois que la boucle est exécutée.

Le booléen peut prendre deux valeurs : true ou false.  Dans notre boucle for, tant que la condition de terminaison est true, la boucle tourne. Dès que la condition n’est plus vérifiée, elle est donc false, et on sort de la boucle !

Découvrez les boucles  for  avec les collections

Vous pouvez utiliser les boucles d'énumération si vous avez besoin d'effectuer une itération sur un tableau ou une collection. Voici un exemple pour les tableaux :

int[] myArray = new int[]{7,2,4};
for (int i=0; i<myArray.length; i++) {
    System.out.println(myArray[i]);
}

Appeler la propriété  length  d’un tableau retourne le nombre d'éléments de ce tableau. Dans cet exemple, il est utilisé comme condition de terminaison de la boucle "for". 

for (int i=0; i<=0; i--) {
    System.out.println(“i sera toujours inférieur à 0!”);
}

Parfois, on ne veut pas spécifier explicitement combien de fois la boucle doit tourner, mais juste qu’elle doit couvrir tous les éléments d’un tableau. Dans ce cas, Java fournit une construction améliorée appelée  for each  , qui a la syntaxe générale suivante :

for (int number: myArray){
   System.out.println(number);
}

Avec la boucle  for each  , il vous suffit de définir une variable du type contenu par le tableau, ou de la collection que vous souhaitez mettre en boucle. Cette variable se verra attribuer la valeur de chaque élément du tableau ou de la collection, jusqu'à ce que vous ayez atteint la fin.

En français, cet exemple donne : Pour chaque int, qui sera à chaque tour de boucle du tableau myArray rangé dans une variable appelé  number  , affiche-moi en console la valeur de  number  .

Répétez la boucle jusqu'à atteindre une condition 

Dans ce cas, la boucle doit continuer tant que la condition du  while  reste vraie. Le nombre de répétitions n'est pas défini par les limites inférieure et supérieure d'un énumérateur, mais par une condition telle que celle d'une instruction  if.

Appréhendez la boucle  while

Voici à quoi ressemble la syntaxe d'une boucle while :

while (logicalExpression) {
// liste de déclarations
}

Elle peut être interprétée comme « tant que l'expression logique est vraie, répétez les instructions ».

Voilà comment cela fonctionne en détail :

1. Le programme vérifie que   logicalExpression  est vrai (  true  ).

2. Si l’expression est fausse (  false  ) : les instructions sont ignorées. Vous n'entrez même pas dans le corps de la boucle située entre   {  et   }  .

3. Si c'est true : la liste des instructions à l'intérieur de   {  et   }  sont exécutées.

4. Une fois les instructions exécutées, vous revenez à la première étape.

Voyons un exemple concret :

int numberOfTrees = 0;
while (numberOfTrees < 10) {
   numberOfTrees += 1;
   System.out.println("I planted " + numberOfTrees + " trees");
}

System.out.println("I have a forest!");

Cela donnera le résultat suivant :

I planted 1 trees
I planted 2 trees
I planted 3 trees
I planted 4 trees
I planted 5 trees
I planted 6 trees
I planted 7 trees
I planted 8 trees
I planted 9 trees
I planted 10 trees
I have a forest!

À chaque tour de boucle, le nombre d'arbres   numberOfTrees  est incrémenté de 1. Lorsque la variable atteint la valeur   10  , le nombre d'arbres  numberOfTrees  <10  n'est plus vrai. Donc, la boucle se termine, et le reste du programme continue. Dans ce cas, le programme affiche "  I have a forest!  " (J'ai une forêt !).

boolean theSunIsUp = true;
while (theSunIsUp) {
   print ("Stay awake...forever!");
   // theSunIsUp ne change jamais
}
// nous n'atteignons jamais ceci
print ("Go to sleep!");

C'est une erreur courante et facile à commettre. Alors, faites attention !

Comme vous pouvez le voir, la condition while est vérifiée AVANT que le bloc de code correspondant puisse être exécuté, même une seule fois ! Cela veut dire que si la condition n’est pas vérifiée, le bloc de code peut ne jamais être exécuté.

Découvrez la boucle  do... while

La boucle do... while est très similaire à la première, mais la condition est placée à la fin du bloc de code correspondant. De cette façon, le bloc de code sera toujours exécuté au moins une fois.

Voici à quoi ressemble la syntaxe :

do {
// instructions
} while(logicalExpression);

Prenons un exemple :

int pushUpGoal = 10;
do{
   print ("Push up!");
   pushUpGoal -= 1;
} while(pushUpGoal > 0);

De cette façon, au moins une pompe (un « push-up ») est effectuée avant même que la condition soit vérifiée. Modifions cela un petit peu pour montrer la différence par rapport à la boucle while d'origine :

Prenons un exemple :

// Boucle "While"
int pushUpGoal = 0;
while(pushUpGoal > 0) {
   System.out.println ("Push up!");
   pushUpGoal -= 1;
   }
// Boucle "do/while"
int pushUpGoal = 0;
do{
   System.out.println ("Push up!");
   pushUpGoal -= 1;
} while (pushUpGoal > 0);

Vous pouvez voir que l'utilisation de la boucle while d'origine n'effectuera pas de « push-up ». La boucle do... while provoquera un push-up une seule fois.

Ignorez quelques instructions à l'intérieur d'une boucle

Dans chaque type de boucle, il peut y avoir des situations où vous souhaitez sauter certaines itérations, ou interrompre toute la boucle prématurément à une certaine condition.

Par exemple, vous pouvez vouloir répéter quelque chose 10 fois, mais ignorer (ou ignorer partiellement) si la valeur est égale à   2  ou   5  . En Java, pour ignorer une itération dans la boucle, utilisez une instruction  continue  :

for ( int i=0; i <10; i++) {
// déclarations exécutées à chaque itération
   if(i == 2 ||i == 5) {
   continue;
   }
System.out.println(“Valeur de i : “ + i + “.”);
}

Vous pouvez également interrompre complètement la séquence, par exemple si vous voulez trouver un élément dans un tableau, et arrêter de chercher une fois cet élément trouvé :

En Java, pour interrompre une séquence d'exécution, utilisez une instruction  break  :

int [] myArray = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };

for (int i =0; i<myArray.length;i++) {
   if (myArray[i] == "50") {
   System.out.println ("J’ai trouvé mon  " +basket[i]+ " !");
   break;
   }
System.out.println ("J’en suis à " +basket[i]+ " ...");
}

Une fois que vous avez trouvé l’élément que vous recherchiez, arrêtez de parcourir le reste du tableau.

À vous de jouer !

Prêt à coder ? Pour accéder à l’exercice, suivez ce lien.

En résumé

• Les boucles d'énumération exécutent un ensemble d'instructions un nombre de fois fixe, basé sur les valeurs limites inférieure et supérieure de l'énumérateur.

• Les boucles conditionnelles exécutent un ensemble d'instructions jusqu'à ce qu'une condition définie soit remplie.

• Une erreur courante à surveiller avec les boucles conditionnelles : les boucles infinies !

• Les itérations dans une boucle peuvent ignorer certaines instructions à l'intérieur de la boucle en utilisant la commande   continue  .

• Le cycle de boucle peut être interrompu et la boucle peut être interrompue prématurément à l'aide de la commande  break  .

Dans le chapitre suivant, nous allons voir comment contrôler le déroulement d'un programme en appliquant des conditions qui vont gérer son comportement selon les situations. Vous me suivez ? On y va !