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 :
-
S'il y a des pommes dans le bassin, suivez les étapes 1.1 à 1.4 :
- 1.1. Prends une pomme
- 1.2. Nettoyez-le et coupez-le en tranches
- 1.3. Disposer sur le fond de tarte dans une poêle
- 1.4. Revenons à l'étape 1.
- 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) :
- Nous évaluons la condition booléenne qui suit le while entre parenthèses.
- 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
- 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) :
- Le corps de la boucle est exécuté (immédiatement après le mot clé do).
- Nous évaluons la condition booléenne qui suit le while entre parenthèses.
- Si la condition logique est vraie, passez à l'étape 1
- Si la condition logique est fausse, passez à la première instruction en dehors de la boucle while.
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 – 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 – немедленно прекращает выполнение текущего цикла и осуществляет переход к первой команде за его пределами. Таким образом, выполнение текущего цикла прерывается. Подробнее мы рассмотрим её в следующей теме.
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.4:
- 1.1. Берем яблоко
- 1.2. Чистим и нарезаем его дольками
- 1.3. Помещаем на основание пирога из теста на сковороде
- 1.4. Возвращаемся на шаг 1.
- Число долек = 0
-
Пока число долек < 12, выполнить шаги с 2.1 по 2.3
- 2.1. Отрезать очередную дольку от яблока
- 2.2. Кол-во долек ++
- 2.3. Возвращаемся на шаг 2
-
Если в тазике есть яблоки, то выполняем шаги с 1.1 по 1.6:
- 1.1. Берем яблоко
- 1.2. Очищаем его от кожуры
- 1.3. Число долек = 0
- 1.4. Пока число долек < 12, выполнить шаги с 1.4.1 по 1.4.3
- 1.4.1. Отрезать очередную дольку от яблока
- 1.4.2. Кол-во долек ++ 1.4.3. Возвращаемся на шаг 1.4
- 1.5. Помещаем дольки на тестовое основание пирога из теста на сковороде
- 1.6. Возвращаемся на шаг 1.
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.
GO TO FULL VERSION