JavaRush /Blog Java /Random-FR /Boucle While en Java

Boucle While en Java

Publié dans le groupe Random-FR

Introduction

Nos tout premiers programmes étaient une séquence d’instructions exécutées les unes après les autres. Pas de fourchettes. Il s'agit de HelloWorld, qui envoie une phrase de bienvenue et des calculs arithmétiques à la console. Après les premiers programmes, nous avons appris à créer des branches, c'est-à-dire que le programme effectuait certaines actions en fonction des conditions. Voici comment coder le climatiseur pour qu'il s'allume pour le chauffage et la climatisation :
if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort
    heaterOn();
Passons à l'étape suivante. Dans la vie de tous les jours, nous effectuons souvent des actions monotones et répétitives, par exemple éplucher des pommes pour une tarte. Ce processus fascinant peut être décrit comme suit :
  1. S'il y a des pommes dans le bassin, suivez les étapes 1.1 à 1.4 :

    1. 1.1. Prends une pomme
    2. 1.2. Nettoyez-le et coupez-le en tranches
    3. 1.3. Disposer sur le fond de tarte dans une poêle
    4. 1.4. Revenons à l'étape 1.
Opérateur pendant - 2
Disons que vous avez 10 pommes, 2 mains et un couteau. Dans la vie, vous nettoyez systématiquement les dix entiers, guidés par le même algorithme. Comment pouvez-vous faire en sorte que le programme effectue une action répétitive avec chaque pomme ?
  • Lions-nous au nombre de pommes, mais si nous en avons peu, certaines commandes seraient exécutées en vain sans « charge utile » (et, peut-être, nous nous couperions en épluchant une pomme inexistante).
  • S’il y a plus de pommes que nos équipes de transformation, certains produits ne seront pas transformés.
  • Un tel « code » est difficile à lire, contient beaucoup de répétitions et est difficile à modifier.

Les boucles sont des opérateurs permettant d'effectuer des actions plusieurs fois.

La boucle Java while (vile boucle) fonctionne bien dans notre cas. Cette conception organise plusieurs actions dans une structure concise et compréhensible. Un algorithme while permettant de trancher des pommes pour une tarte en Java pourrait ressembler à ceci :
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');

Syntaxe des commandes

La première façon de décrire l’instruction while est la suivante :
while(Логическое выражение) {
	// Loop body - periodically executed statement(s)
}
Cela se fait comme suit (étape par étape) :
  1. Nous évaluons la condition booléenne qui suit le while entre parenthèses.
  2. Si la condition logique est vraie, alors les opérateurs dans le corps de la boucle sont exécutés, après avoir exécuté le dernier opérateur dans le corps de la boucle, passez à l'étape 1
  3. Si la condition logique est fausse, passez à la première instruction en dehors de la boucle while.

Boucle avec précondition

Puisqu'avant d'exécuter le corps de la boucle, on pré-calcule toujours une expression logique (la condition d'entrée dans la boucle), ce type de while est souvent appelé boucle avec une précondition. Construisons un tableau des dix premiers entiers, puissances positives d'un nombre :
public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(power <= 10) { // loop entry condition
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
    }
}
Résultat de la sortie de la console :
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

Boucle avec postcondition

Deuxième type de cycle :
do {
    // Loop body - periodically executed statement(s)
}while (Логическое выражение);
Effectué comme suit (étapes) :
  1. Le corps de la boucle est exécuté (immédiatement après le mot clé do).
  2. Nous évaluons la condition booléenne qui suit le while entre parenthèses.
  3. Si la condition logique est vraie, passez à l'étape 1
  4. Si la condition logique est fausse, passez à la première instruction en dehors de la boucle while.
Deux différences principales avec le type de boucle précédent : le corps de la boucle est exécuté au moins une fois et la condition logique est vérifiée après l'exécution du corps de la boucle. Par conséquent, ce type de boucle while est appelé boucle de postcondition. Cette fois nous afficherons un tableau de puissances d'un nombre n'excédant pas 10000 :
public static void main(String[] args) {
    int number = 3;// Number to be raised to a power
    int result = number;// Result of exponentiation
    int power = 1;// Initial exponent
    do {
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        result = result * number;
    }while (result < 10000); // loop exit condition
Résultat de la sortie de la console :
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
Process finished with exit code 0
Faites attention aux changements dans le code, en le comparant avec la version de la boucle avec une précondition.

Faits intéressants sur le travail avec des boucles

Commandes de contrôle dans le corps de la boucle

Il existe deux commandes qui affectent la progression de la boucle : break, dont nous montrerons les fonctionnalités dans le chapitre suivant, et continuer.
  • continuer – arrête l’exécution du corps de la boucle actuelle et passe à l’expression logique de l’opérateur while. Si l'expression calculée est vraie, l'exécution de la boucle continuera.
  • break – немедленно прекращает выполнение текущего цикла и осуществляет переход к первой команде за его пределами. Таким образом, выполнение текущего цикла прерывается. Подробнее мы рассмотрим её в следующей теме.
Вспомним про наш фруктовый пример. Если мы не уверены в качестве предложенных яблок, то могли бы изменить code с применением команды continue:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
    if (яблоко.плохое()) {  // method will return true for rotten, etc. apples
        яблоко.выкинутьВМусор();
        continue; // continue the loop, go to the condition number ofApplesIn the Basin>0
    }
    положитьВПирог(яблоко.чистить().нарезать());
}
Конструкцию continue часто применяют, когда в теле цикла необходимо выполнять команды при наступлении некоторого условия, например, выполнить действия при срабатывании датчика в оборудовании (а иначе просто продолжить цикл считывания его показателей) or вычислить выражение только на определенных шагах цикла. Пример для последнего случая – вычисление в цикле while суммы кубов натуральных чисел, у которых квадрат меньше их количества:
public static void main(String[] args) {
    int sum = 0;    // total amount
    int i = 0;      // starting number of the row
    int count = 20; // amount of numbers
    while(i<=count) {
        i++;        // take the next number, i++ is equivalent to i=i+1
        if (i*i<=count)  // if the square of the number is less
            continue;   // number of numbers - do not count the sum
                        // move on to the next number in the loop
        sum += i*i*i; // otherwise, we calculate the sum of cubes of numbers
    } // sum += i*i*i - notation similar to sum = sum + i*i*i
    System.out.println(sum);// print result
}

Бесконечный цикл

Данные управляющие команды чаще всего находят применение в бесконечном цикле. Его так называют, потому что логическое condition выхода никогда не выполняется. В codeе он выглядит примерно How:
while(true) {
    // Loop body
}
В этом случае и пригодится применение команды break для организации выхода из него. Этот вид цикла имеет место при ожидании внешних условий, которые формируются за пределами логики тела цикла. Например, в играх, эмулирующих виртуальный мир вокруг героя (выход из цикла = выход из игры), операционных системах. Или при использовании алгоритмов, возможно, улучшающих результат с каждым последующим вызовом в цикле, но ограничивая их по времени or наступлению внешнего события (шашки, шахматы or предсказание погоды). Следует помнить, что в обычных условиях бесконечные циклы – одна из проблем неустойчивости программы. Для демонстрации вернёмся к степеням числа:
public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(true) {
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        if (power>10)
            break; // exit from the loop
    }
}
Результат вывода на консоль:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

Вложенные циклы

Вот мы и подошли к завершающей теме о наших циклах. Вспомним о яблочном пироге (надеюсь, вы не голодны в данный момент) и наш «цикл»:
  1. Если в тазике есть яблоки, выполняем шаги с 1.1 по 1.4:

    1. 1.1. Берем яблоко
    2. 1.2. Чистим и нарезаем его дольками
    3. 1.3. Помещаем на основание пирога из теста на сковороде
    4. 1.4. Возвращаемся на шаг 1.
Подробнее распишем процесс нарезания дольками:
  1. Число долек = 0
  2. Пока число долек < 12, выполнить шаги с 2.1 по 2.3

    1. 2.1. Отрезать очередную дольку от яблока
    2. 2.2. Кол-во долек ++
    3. 2.3. Возвращаемся на шаг 2
И вставим в наш кондитерский алгоритм:
  1. Если в тазике есть яблоки, то выполняем шаги с 1.1 по 1.6:

    1. 1.1. Берем яблоко
    2. 1.2. Очищаем его от кожуры
    3. 1.3. Число долек = 0
    4. 1.4. Пока число долек < 12, выполнить шаги с 1.4.1 по 1.4.3
      1. 1.4.1. Отрезать очередную дольку от яблока
      2. 1.4.2. Кол-во долек ++
      3. 1.4.3. Возвращаемся на шаг 1.4
    5. 1.5. Помещаем дольки на тестовое основание пирога из теста на сковороде
    6. 1.6. Возвращаемся на шаг 1.
Получor цикл в цикле. Подобные конструкции весьма частые. Для завершающего примера построим таблицу умножения, которые школьники 90-х видели на обложках тетрадей в младших классах.
Opérateur pendant - 3
public static void main(String[] args) {
    // Display the values ​​of the second multiplier in the line
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;      // first multiplier, assign starting value
    while(i<10) {   // First loop, execute while the first multiplier is less than 10
        System.out.print(i + " | ");// Display the first multiplier at the beginning of the string
        int j = 2;                  // second multiplier, starting value
        while (j<10) { // Second loop, execute while the second multiplier is less than 10
            int mul=i*j; // Calculate the product of factors
            if (mul<10)  // If it contains one digit, print two spaces after it
                System.out.print(mul + "  ");
            else   // otherwise output the product and after it - one space
                System.out.print(mul + " ");
            j++;     // Increase the second multiplier by one,
        }            // Go to the beginning of the second loop (while (j<10 ).... )
        System.out.println(); // Move to the next line of output
        i++;                  // Increase the first multiplier by one,
    }                         // Go to the beginning of the first loop (while ( i<10 ) ....
}
Результат вывода на консоль:
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 de la construction d’un programme. En résolvant des problèmes dans JavaRush, vous étudierez toute leur diversité, comprendrez les subtilités de leur fonctionnement et acquerrez des compétences pratiques dans leur application.
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION