• 15 heures
  • Facile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 19/05/2021

Écrivez une boucle dans vos fonctions

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Imaginez que vous ayez un bloc de code que vous devez répéter plusieurs fois. Vous pouvez l'inclure dans une fonction et appeler cette fonction autant de fois que vous le voulez. Cela pourrait faire l'affaire. Pourtant, la plupart du temps, vous ne savez même pas à l'avance combien de fois vous devrez l'appeler.

Les boucles permettent de résoudre ce problème !

En programmation, une boucle est une technique qui permet de répéter une ou plusieurs instructions sans avoir à retaper le même ensemble d'instructions plusieurs fois.

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!");

Pouvez-vous imaginer si nous voulions applaudir non pas cinq, mais 42 ou 1 001 fois ?

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

for (initialization; termination; increment) {
// liste de déclarations
}
  1. L'initialisation est une expression qui initialise 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 une 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. Un incrément est une expression qui est évaluée chaque fois qu'une itération 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.

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]);
}

Un tableau a une propriété de longueur  length  qui retourne le nombre d'éléments du tableau. Dans cet exemple, il est utilisé comme condition de terminaison de la boucle "for". Parfois, vous ne vous souciez pas de l'index et voulez simplement afficher la valeur contenue dans le tableau ou la collection. Dans ce cas, Java fournit une construction améliorée qui a la syntaxe générale suivante :

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

Avec le "for" amélioré, il vous suffit de définir une variable du type du 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.

La boucle for est idéale si vous voulez faire une boucle pour un nombre prédéfini de fois ou sur tous les éléments d'un tableau. Si cela n'est pas le cas, Java fournit un moyen plus général de faire des boucles avec des boucles conditionnelles.

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

Les boucles conditionnelles sont également appelées boucles while. Il en existe deux types :

  • "while" ;

  • "do... while".

Dans ce cas, la boucle doit continuer pendant que ("while") ou « aussi longtemps que ».  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 « un ». 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 !).

❗️ Il est important de garder à l'esprit que l'utilisation de boucles while peut provoquer le crash d'un programme. ☠️ Si l'expression reste  true  pour toujours, le programme reste bloqué dans la boucle, provoquant ce qu'on appelle une boucle infinie :

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 !

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-ups ». 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;
}
// déclarations non-exécutées quand i == 2 or 5
}

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  :

String[] basket = new String[]{"apple", "orange", "banana"};
for (int i =0; i<basket.length;i++) {
if (basket[i] == "orange") {
System.out.println ("I have an " +basket[i]+ " !");
break;
}
}

Une fois que vous avez trouvé un élément que vous recherchez, arrêtez de parcourir le reste d'un tableau.

À vous de jouer !

Console de code
Houston... ?
Il semblerait que votre ordinateur ne soit pas connecté à Internet.
Vous n'êtes pas connecté

Connectez-vous pour accéder aux exercices de codes et testez vos nouvelles compétences.

Pensez à vous entraîner avant de terminer ce chapitre.

En résumé

Dans ce chapitre, vous avez appris que :

  • 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 prochain chapitre, une courte vidéo reviendra sur les concept clés que nous avons avons abordés tout au long de cette première partie.

Exemple de certificat de réussite
Exemple de certificat de réussite