Boucle while

Voici la syntaxe de base pour une boucle while :

1
2
3
4
while (condition) {
    // bloc de code
    // mécanisme de mise à jour
}

C’est important de noter que l’exécution des instructions ne continue pas après le bloc de code mais revient à la condition. C’est ça qui forme la boucle. Si la condition est true, le bloc de code est répété. Si la condition est false, l’exécution continue après la boucle. Ici, le diagramme de flux donne une meilleure représentation de l’exécution réelle de étapes.

Exemple : Traiter une suite de nombres

Pour traiter une suite de nombres, on définit d’abord une variable de contrôle qui représente la valeur initiale de la suite. Ensuite, on définit la condition de la boucle en fonction de cette variable de contrôle. Finalement, on met à jour la variable de contrôle à l’intérieur du bloc de code.

Placez le code suivant dans un fichier qui s’appelle LoopExamples1.java et exécutez-le pour voir les résultats.

Par exemple, pour afficher les nombres de 1 à 10 :

Avec while

1
2
3
4
5
6
7
8
9
10
11
void whileLoop() {
    int i = 1;          // initialiser la variable de contrôle
    while (i <= 10) {   // condition utilisant la variable de contrôle
        System.out.println(i);
        i++; // mise à jour de la variable de contrôle (incrémenter)
    }
}

void main() {
    whileLoop();
}

1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

Avec for

La boucle for est spécialisée pour ce type de tâche. Elle inclut les trois éléments clés de la boucle directement dans sa déclaration. Sa syntaxe est la suivante :

1
2
3
for (initialisation; condition; mise à jour) {
    // bloc de code
}

Par exemple, pour afficher les nombres de 1 à 10 avec une boucle for :

1
2
3
4
5
void forLoop() {
    for (int i = 1; i <= 10; i++) { // les trois éléments séparés par des ;
        System.out.println(i);
    }
}

Si on appelle aussi cette méthode dans main, on aura exactement la même sortie qu’avec la version while. Ajoutez-le à votre fichier LoopExamples1.java pour le vérifier.

Défi

Pouvez vous trouver et afficher la somme de toutes les valeurs de 1 à 10 en modifiant une des boucles ci-dessus?

Indice : vous aurez besoin d’une variable accumulateur en plus de la variable de contrôle.

Exemple : Valider des données d’entrée

Un autre contexte pour une boucle est demander une réponse à l’utilisateur tant que la réponse n’est pas valide.

Une situation typique est lorsqu’on demande une confirmation oui/non à l’utilisateur. On peut utiliser une boucle while pour s’assurer que la réponse est valide.

Voici deux façons de le faire. Il en existe d’autres! Vous pouvez tester ces méthodes dans un nouveau fichier LoopExamples2.java.

Avec une variable de contrôle pour la condition de la boucle

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.*;

final Scanner INPUT = new Scanner(System.in);

String again() {
    String answer = ""; // variable : contrôle ET accumulateur

    while (!(answer.equals("oui") || answer.equals("non"))) { 
        System.out.print("Voulez-vous continuer? (oui/non) > ");
        answer = INPUT.next().toLowerCase();
            // mise à jour avec une réponse en minuscules
    }
    return answer;
}

void main() {
    while (again().equals("oui")) {
        // code à répéter
    }
    System.out.println("Au revoir");
}

Il y a deux conditions dans ce code.

Le plus complexe est dans again() : !(answer.equals("oui") || answer.equals("non")) :

• Le ! au début indique qu’on veut inverser le résultat entre les parenthèses - c’est parce que ce qu’on décrit entre parenthèses correspond à ce que nous voulons, mais la boucle devrait se répéter dans le cas contraire
• Le || est l’opérateur “ou” qui sera vrai si l’une ou l’autre des conditions est vraie.
• On utilise .equals() pour comparer l’égalité parce qu’on compare deux String.

Plaçant tout ça ensemble avec le mot-clé while, on devrait lire :

1
si la réponse EST "oui" OU "non", NE PAS répéter le bloc de code

La deuxième condition est dans main : again().equals("oui") :

• again retourne un String au programme qui est directement utilisé dans la comparaison

Voici un exemple d’interaction avec l’utilisateur pour ce programme :

1
2
3
4
Voulez-vous continuer? (oui/non) > peut-être
Voulez-vous continuer? (oui/non) > n
Voulez-vous continuer? (oui/non) > Non
Au revoir

Défi

La condition pour évaluer si la réponse était invalide (alors répéter la boucle) est la suivante :

!(answer.equals("oui") || answer.equals("non")) = si la réponse EST "oui" OU "non", NE PAS répéter le bloc de code

On peut écrire cette même condition d’une autre façon.

Exemple : Répéter un programme jusqu’à ce que l’utilisateur décide de le quitter

Un autre contexte commun est une boucle de programme intentionellement infinie. Pour ces cas, la déclaration de la boucle est while (true). C’est ce qui se passe avec les fenêtres de vos applications : l’affichage est rafraîchi en permanence jusqu’à ce que vous fermiez la fenêtre.

Mais comment quitter une boucle où la condition de boucle est une constante? Réponse : on utilise une instruction break à l’intérieur du bloc de code. L’instruction break est insérée dans une sélection qui évalue si la condition de sortie est atteinte.

1
2
3
4
5
6
while (true) { // passe tout droit
    // bloc de code
    if (condition) {
        break; // sortie de la boucle
    }
}

Notez que le mot-clé while n’apparaît jamais dans ces diagrammes, ni les autres mot-clés (p. ex.: if, else, true, break). Il s’agit simplement de conditions et d’embranchements dans les diagrammes. Dans les divers cas d’itération, une des branches forme une boucle. Sinon on parle de sélection / d’embranchement tout court.

Retour sur la validation de données

On pourrait remplacer la version de main dans LoopExamples2.java avec la version suivante :

1
2
3
4
5
6
7
8
9
10
11
12
13
void main() {
    while (true) {
        // code de la tâche

        // code pour demander à l'utilisateur s'il veut continuer

        if (again().equals("non")) {
            break; // sortie de la boucle
        } else {
            // code pour réinitialiser les variables de la tâche
        }
    }
}

Pour d’autres tâches

Un autre exemple est pour faire la somme d’une série de nombres. On demande à l’utilisateur d’entrer un nombre à la fois. Si le nombre est -999, on quitte la boucle. Sinon, on ajoute le nombre à la somme.

Reprendre cet exemple dans un nouveau fichier LoopExamples3.java.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.*;

void main() {
    Scanner input = new Scanner(System.in);

    int sum = 0; // variable accumulateur

    while (true) {
        System.out.print(
            "Entrez un nombre entier (-999 pour quitter) : "
        );
        
        int num = input.nextInt(); // variable de contrôle
        if (num == -999) {
            break; // mot-clé pour quitter la boucle
        } else {
            sum += num;
        }
    }
    System.out.println("La somme est " + sum);
}

Et voici deux exemples d’interaction avec l’utilisateur :

1
2
3
4
5
Entrez un nombre entier (-999 pour quitter) : 5
Entrez un nombre entier (-999 pour quitter) : 10
Entrez un nombre entier (-999 pour quitter) : 15
Entrez un nombre entier (-999 pour quitter) : -999
La somme est 30

1
2
3
4
5
6
Entrez un nombre entier (-999 pour quitter) : -3
Entrez un nombre entier (-999 pour quitter) : 0
Entrez un nombre entier (-999 pour quitter) : 3
Entrez un nombre entier (-999 pour quitter) : 6
Entrez un nombre entier (-999 pour quitter) : -999
La somme est 6