Maîtriser les boucles while et do-while en Java : Tutoriel pas à pas

Boucles while et do...while en Java

Dans ce tutoriel, nous allons apprendre comment utiliser les boucles while et do while en Java avec des exemples.

En programmation informatique, les boucles sont utilisées pour répéter un bloc de code. Par exemple, si vous voulez afficher un message 100 fois, vous pouvez utiliser une boucle. C'est juste un exemple simple ; vous pouvez accomplir bien plus avec les boucles.

Dans le tutoriel précédent, vous avez appris la boucle for en Java. Ici, vous allez apprendre les boucles while et do...while.

---

Boucle while en Java

La boucle while en Java est utilisée pour exécuter un code spécifique jusqu'à ce qu'une certaine condition soit remplie. La syntaxe de la boucle while est :

while (testExpression) {
    // corps de la boucle
}

Ici,

1. Une boucle while évalue la testExpression à l'intérieur des parenthèses ().
2. Si la testExpression évalue à true, le code à l'intérieur de la boucle while est exécuté.
3. La testExpression est évaluée à nouveau.
4. Ce processus se poursuit jusqu'à ce que la testExpression soit false.
5. Quand la testExpression évalue à false, la boucle s'arrête.

Pour en savoir plus sur les conditions, visitez Opérateurs relationnels et logiques Java.

---

Diagramme de flux de la boucle while

---

Exemple 1 : Afficher les nombres de 1 à 5

// Programme pour afficher les nombres de 1 à 5
class Main {
    public static void main(String[] args) {
        // déclarer variables
        int i = 1, n = 5;
        // boucle while de 1 à 5
        while(i <= n) {
            System.out.println(i);
            i++;
        }
    }
}

Sortie

1
2
3
4
5

Voici comment ce programme fonctionne.

Itération	Variable	Condition : i <= n	Action
1ère	i = 1 n = 5	true	1 affiché. i augmenté à 2.
2ème	i = 2 n = 5	true	2 affiché. i augmenté à 3.
3ème	i = 3 n = 5	true	3 affiché. i augmenté à 4.
4ème	i = 4 n = 5	true	4 affiché. i augmenté à 5.
5ème	i = 5 n = 5	true	5 affiché. i augmenté à 6.
6ème	i = 6 n = 5	false	La boucle est terminée

---

Exemple 2 : Somme des nombres positifs uniquement

// Programme Java pour trouver la somme des nombres positifs
import java.util.Scanner;
class Main {
    public static void main(String[] args) {
        int sum = 0;
        // créer un objet de la classe Scanner
        Scanner input = new Scanner(System.in);
        // prendre une entrée entière de l'utilisateur
        System.out.println("Enter a number");
        int number = input.nextInt();
        // la boucle while continue
        // jusqu'à ce que le nombre entré soit positif
        while (number >= 0) {
            // ajouter seulement les nombres positifs
            sum += number;
            System.out.println("Enter a number");
            number = input.nextInt();
        }
        System.out.println("Sum = " + sum);
        input.close();
    }
}

Sortie

Enter a number
25
Enter a number
9
Enter a number
5
Enter a number
-3
Sum = 39

Dans le programme ci-dessus, nous avons utilisé la classe Scanner pour prendre l'entrée de l'utilisateur. Ici, nextInt() prend une entrée entière de l'utilisateur.

La boucle while continue jusqu'à ce que l'utilisateur entre un nombre négatif. À chaque itération, le nombre entré par l'utilisateur est ajouté à la variable sum.

Quand l'utilisateur entre un nombre négatif, la boucle se termine. Finalement, la somme totale est affichée.

---

Boucle do...while en Java

La boucle do...while est similaire à la boucle while. Cependant, le corps de la boucle do...while est exécuté une fois avant que l'expression de test ne soit vérifiée. Par exemple,

do {
    // corps de la boucle
} while(testExpression);

Ici,

1. Le corps de la boucle est exécuté en premier. Ensuite, la testExpression est évaluée.
2. Si la testExpression évalue à true, le corps de la boucle à l'intérieur de l'instruction do est exécuté à nouveau.
3. La testExpression est évaluée une fois de plus.
4. Si la testExpression évalue à true, le corps de la boucle à l'intérieur de l'instruction do est exécuté à nouveau.
5. Ce processus se poursuit jusqu'à ce que la testExpression évalue à false. Alors la boucle s'arrête.

---

Diagramme de flux de la boucle do...while

---

Voyons le fonctionnement de la boucle do...while.

Exemple 3 : Afficher les nombres de 1 à 5

// Programme Java pour afficher les nombres de 1 à 5
import java.util.Scanner;
// Programme pour trouver la somme des nombres naturels de 1 à 100.
class Main {
    public static void main(String[] args) {
        int i = 1, n = 5;
        // boucle do...while de 1 à 5
        do {
            System.out.println(i);
            i++;
        } while(i <= n);
    }
}

Sortie

1
2
3
4
5

Voici comment ce programme fonctionne.

Itération	Variable	Condition : i <= n	Action
	i = 1 n = 5	non vérifiée	1 affiché. i augmenté à 2.
1ère	i = 2 n = 5	true	2 affiché. i augmenté à 3.
2ème	i = 3 n = 5	true	3 affiché. i augmenté à 4.
3ème	i = 4 n = 5	true	4 affiché. i augmenté à 5.
4ème	i = 5 n = 5	true	6 affiché. i augmenté à 6.
5ème	i = 6 n = 5	false	La boucle est terminée

---

Exemple 4 : Somme des nombres positifs

// Programme Java pour trouver la somme des nombres positifs
import java.util.Scanner;
class Main {
    public static void main(String[] args) {
        int sum = 0;
        int number = 0;
        // créer un objet de la classe Scanner
        Scanner input = new Scanner(System.in);
        // boucle do...while continue
        // jusqu'à ce que le nombre entré soit positif
        do {
            // ajouter seulement les nombres positifs
            sum += number;
            System.out.println("Enter a number");
            number = input.nextInt();
        } while(number >= 0);
        System.out.println("Sum = " + sum);
        input.close();
    }
}

Sortie 1

Enter a number
25
Enter a number
9
Enter a number
5
Enter a number
-3
Sum = 39

Ici, l'utilisateur entre un nombre positif, ce nombre est ajouté à la variable sum. Et ce processus continue jusqu'à ce que le nombre soit négatif. Quand le nombre est négatif, la boucle se termine et affiche la somme sans ajouter le nombre négatif.

Sortie 2

Enter a number
-8
Sum is 0

Ici, l'utilisateur entre un nombre négatif. La condition de test sera false mais le code à l'intérieur de la boucle s'exécute une fois.

---

Boucle while infinie

Si la condition d'une boucle est toujours true, la boucle s'exécute indéfiniment (jusqu'à ce que la mémoire soit pleine). Par exemple,

// boucle while infinie
while(true){
    // corps de la boucle
}

Voici un exemple de boucle do...while infinie.

// boucle do...while infinie
int count = 1;
do {
    // corps de la boucle
} while(count == 1)

Dans les programmes ci-dessus, la testExpression est toujours true. Donc, le corps de la boucle s'exécutera indéfiniment.

---

Boucles for et while

La boucle for est utilisée quand le nombre d'itérations est connu. Par exemple,

for (let i = 1; i <=5; ++i) {
    // corps de la boucle
}

Et les boucles while et do...while sont généralement utilisées quand le nombre d'itérations est inconnu. Par exemple,

while (condition) {
    // corps de la boucle
}