CodeGym /Blog Java /Random-FR /L'instruction While

Niveau 41

San Francisco

21 juillet 2023
45 views
0 comments

L'instruction While

Nos tout premiers programmes étaient une séquence d'instructions exécutées les unes après les autres. Pas de fourches. Cela inclut HelloWorld, qui affiche un message d'accueil. Il comprend des calculs arithmétiques. Après nos premiers programmes, nous avons appris à créer des branches, c'est-à-dire à faire en sorte qu'un programme effectue différentes actions en fonction de conditions spécifiques. Voici le code pour contrôler un système de chauffage et de climatisation central :

if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort)
    heaterOn();

Passez à l'étape suivante. Dans la vie de tous les jours, nous effectuons souvent des actions répétitives uniformes, par exemple, éplucher des pommes pour une tarte. Ce processus fascinant peut être décrit comme suit :

S'il y a des pommes dans le bol, nous exécutons les étapes 1.1 à 1.4 :
1. 1.1. Prenez une pomme
2. 1.2. Pelez-le et coupez-le en tranches
3. 1.3. Disposer les tranches de pomme dans la pâte à tarte dans un moule
4. 1.4. Revenez à l'étape 1.

Disons que vous avez dix pommes, deux mains et un couteau. Dans la vraie vie, vous épluchez séquentiellement la douzaine entière, en suivant le même algorithme pour chaque pomme. Mais comment fait-on pour qu'un programme fasse une action répétitive pour chaque pomme ?

Nous nous attachons au nombre de pommes, mais si nous n'en avons pas assez, certaines commandes seraient exécutées sans "charge utile" (et nous pourrions nous couper en essayant d'éplucher une pomme inexistante).
S'il y a plus de pommes qu'il n'y a de commandes à peler, certaines pommes resteront non pelées.
Un tel code est difficile à lire. Il a beaucoup de répétitions et est difficile à modifier.

Les boucles sont des instructions qui permettent d'effectuer des actions à plusieurs reprises

La boucle while de Java fonctionnera bien dans notre cas. Cette construction place plusieurs actions dans une structure concise et compréhensible. En utilisant une boucle while , un algorithme de découpage de pommes pour une tarte pourrait ressembler à ceci en Java :

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    arrangeInPie(apple.peel().slice());
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");

Syntaxe de la commande

La première variante de l' instruction while ressemble à ceci :

while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}

Voici une explication étape par étape de ce qui se passe lorsque ce code est exécuté :

Nous évaluons l'expression booléenne trouvée entre parenthèses après le mot-clé while .
Si l'expression booléenne prend la valeur true, les instructions du corps de la boucle sont exécutées. Une fois la dernière instruction du corps de la boucle exécutée, nous passons à l'étape 1
Si l'expression booléenne prend la valeur false, nous passons à la première instruction après la boucle while .

Boucle avec une condition préalable

Comme nous évaluons toujours l'expression booléenne (la condition pour entrer dans la boucle) avant d'exécuter le corps de la boucle, cette forme de boucle while est souvent appelée une boucle avec une précondition . Construisons un tableau des dix premières puissances d'un nombre :

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (exponent <= 10) { // The condition for entering the loop
        result = result * base;
        System.out.println(number + " raised to the power of " + exponent + " = " + result);
        exponent++;
    }
}

Sortie console :

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Boucle avec une postcondition

Voici la deuxième variante de cette boucle :

do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);

Voici une explication de ce qui se passe lorsque ce code est exécuté :

Le corps de la boucle est exécuté (immédiatement après le mot clé do ).
Nous évaluons l'expression booléenne trouvée entre parenthèses après le mot-clé while .
Si l'expression booléenne est évaluée à vrai, alors nous passons à l'étape 1
Si l'expression booléenne prend la valeur false, nous passons à la première instruction après la boucle while .

Les deux principales différences par rapport à la boucle précédente sont : 1) le corps de la boucle est exécuté au moins une fois et 2) l'expression booléenne est évaluée après l'exécution du corps de la boucle. Par conséquent, ce type de boucle while est appelé une boucle avec une postcondition . Cette fois, nous allons afficher un tableau des puissances d'un nombre qui ne dépasse pas 10000 :

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = number; // The result of exponentiation
    int exponent = 1; // The initial exponent
    do {
        System.out.println(number + " raised to the power of " + exponent + " = " + result);
        exponent++;
        result = result * number;
    } while (result < 10000); // The condition for exiting the loop

Sortie console :

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0

Faites attention aux changements dans le code. Comparez cela avec la boucle avec une condition préalable.

Faits intéressants sur le travail avec des boucles

Instructions de branchement dans le corps de la boucle

Il y a deux instructions qui affectent l'exécution dans une boucle : break (dont nous parlerons plus en détail dans le chapitre suivant) et continuer.

continue — ignore l'exécution du reste du corps de la boucle dans l'itération en cours et passe à l'évaluation de l'expression booléenne de l'instruction while. Si l'expression a la valeur true, la boucle continue.
break — termine immédiatement l'exécution de l'itération en cours et transfère le contrôle à la première instruction après la boucle. Ainsi, cette instruction termine l'exécution de la boucle en cours. Nous y reviendrons plus en détail dans le prochain article.

Rappelez-vous notre exemple de fruits. Si nous ne sommes pas sûrs de la qualité des pommes, nous pouvons modifier le code en utilisant une instruction continue :

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
    if (apple.isBad()) { // This method returns true for rotten apples
        apple.throwInGarbage();
        continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
    }
    arrangeInPie(apple.peel().slice());
}

L' instruction continue est souvent utilisée lorsque des instructions dans le corps de la boucle doivent être exécutées si une certaine condition est satisfaite. Par exemple, nous pouvons vouloir effectuer des actions lorsqu'un capteur matériel est déclenché (sinon, continuer simplement la boucle dans laquelle nous prenons des mesures de capteur) ou nous pouvons vouloir calculer une expression uniquement sur certaines itérations d'une boucle. Un exemple de ce dernier cas peut être vu dans notre utilisation d'une boucle while pour calculer la somme de cubes de nombres naturels dont le carré est inférieur au nombre de nombres. Confus? Découvrez le code suivant :

public static void main(String[] args) {
    int sum = 0;  // Total amount
    int i = 0;  // Initial number in the series
    int count = 20;  // Number of numbers
    while (i <= count) {
        i++;  // Get the next number — "i++" is equivalent to "i = i + 1"
        if (i * i <= count)  // If the square of the number is less than
            continue;  // the number of numbers, then we won't calculate the sum
                            // Jump to the next number in the loop
        sum += i * i * i;  // Otherwise, we calculate the sum of the cubes of numbers
    }  // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
    System.out.println(sum);  // Print the result
}

Boucle infinie

Ces instructions de branchement sont le plus souvent utilisées dans des boucles infinies. On appelle une boucle infinie si la condition booléenne de sortie de boucle n'est jamais satisfaite. Dans le code, cela ressemble à ceci :

while (true) {
    // Loop body
}

Dans ce cas, une instruction break nous aide à sortir de la boucle. Ce type de boucle est adapté lors de l'attente de conditions extérieures déterminées à l'extérieur du corps de la boucle. Par exemple, dans les systèmes d'exploitation ou les jeux (sortir de la boucle signifie quitter le jeu). Ou lors de l'utilisation d'algorithmes qui tentent, à chaque itération d'une boucle, d'améliorer un résultat, mais limitent le nombre d'itérations en fonction du temps écoulé ou de l'occurrence d'un événement externe (par exemple, dames, échecs ou prévisions météorologiques). Rappelez-vous que dans des conditions normales, les boucles infinies ne sont pas souhaitables. Pour démontrer, revenons à l'exponentiation :

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (true) {
        result = result * number;
        System.out.println(number + " raised to the power of " + exponent + " = " + result);
        exponent++;
        if (exponent > 10)
            break; // Exit the loop
    }
}

Sortie console :

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Boucles imbriquées

Et maintenant, nous arrivons à notre dernier sujet sur les boucles. Rappelez-vous cette tarte aux pommes (j'espère que vous n'avez pas faim en ce moment) et notre boucle d'épluchage de pommes :

S'il y a des pommes dans le bol, nous exécutons les étapes 1.1 à 1.4 :
1. 1.1. Prenez une pomme
2. 1.2. Pelez-le et coupez-le en tranches
3. 1.3. Disposer les tranches de pomme dans la pâte à tarte dans un moule
4. 1.4. Revenez à l'étape 1.

Décrivons plus en détail le processus de découpage :

Nombre de tranches = 0
Tant que le nombre de tranches est < 12, effectuez les étapes 2.1 à 2.3
1. 2.1. Couper une autre tranche de pomme
2. 2.2. Nombre de tranches++
3. 2.3. Retour à l'étape 2

Et nous ajouterons ceci à notre algorithme de fabrication de tarte :

S'il y a des pommes dans le bol, nous exécutons les étapes 1.1 à 1.6 :
1. 1.1. Prenez une pomme
2. 1.2. Peler
3. 1.3. Nombre de tranches = 0
4. 1.4. Tant que le nombre de tranches est <12, puis effectuez les étapes 1.4.1 à 1.4.3
5. 1.5. Disposer les tranches de pomme dans la pâte à tarte dans un moule
6. 1.6. Revenez à l'étape 1.

Nous avons maintenant une boucle dans une boucle. Des constructions comme celle-ci sont très courantes. Comme dernier exemple, construisons l'une des tables de multiplication que nous avons appris à aimer à l'école primaire.

public static void main(String[] args) {
    // Print the second factors in a row
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;  // Assign the first factor to the variable
    while (i < 10) {  // First loop: execute as long as the first factor is less than 10
        System.out.print(i + " | ");  // Print the first factor at the beginning of the line
        int j = 2;  // The starting value of the second factor
        while (j <10) { // Second loop: execute as long as the second factor is less than 10
            int product = i * j;  // Calculate the product of the factors
            if (product <10)  // If the product is a single digit, then we print two spaces after the product
                System.out.print(product + "  ");
            else  // Otherwise, print the product and one space after it
                System.out.print(product + " ");
            j++;  // Increment the second factor by one
        }  // Go to the beginning of the second loop, i.e. "while (j < 10)"
        System.out.println();  // Move to the next line on the console
        i++;  // Increment the first factor by one
    } // Go to the beginning of the first loop, i.e. "while (i < 10)"
}

Sortie console :

     2  3  4  5  6  7  8  9

2 | 4  6  8  10 12 14 16 18 

3 | 6  9  12 15 18 21 24 27

4 | 8  12 16 20 24 28 32 36

5 | 10 15 20 25 30 35 40 45

6 | 12 18 24 30 36 42 48 54

7 | 14 21 28 35 42 49 56 63

8 | 16 24 32 40 48 56 64 72

9 | 18 27 36 45 54 63 72 81

Process finished with exit code 0

Les boucles (en particulier l' instruction while ) sont l'un des éléments fondamentaux du logiciel. En résolvant des tâches sur CodeGym, vous apprendrez tous les différents types de boucles, comprendrez leurs subtilités et acquerrez des compétences pratiques pour les utiliser.

Commentaires

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION