Do while java не выходит из цикла
Введение
Наши самые первые программы представляли собой последовательность инструкций, которые выполняются одна за другой. Без развилок. Это и HelloWorld, выводящий в консоль фразу приветствия, арифметические вычисления. 
После первых программ мы научились ветвлению, то есть программа выполняла те или иные действия в зависимости от условий. Вот как можно было бы закодировать включение кондиционера на обогрев и охлаждение:
if (tempRoom>tempComfort) airConditionerOn(); if (tempRoom<tempComfort heaterOn();
Сделаем следующий шаг. В быту мы часто выполняем однообразные повторяющиеся действия, например, чистим яблоки для пирога. Этот увлекательный процесс можно описать как:
Если в тазике есть яблоки, то выполняем шаги с 1.1 по 1.4:
- 1.1. Берём яблоко
- 1.2. Чистим и нарезаем его дольками
- 1.3. Помещаем на основание пирога из теста на сковороде
- 1.4. Возвращаемся на шаг 1.
Допустим у вас 10 яблок, 2 руки и один нож. В жизни вы последовательно чистите весь десяток, руководствуясь одним и тем же алгоритмом. А как заставить программу делать повторяющееся действие с каждым яблоком?
- Привяжем себя к числу яблок,но если у нас их мало – часть команд выполнялось бы вхолостую без «полезной нагрузки» (и, возможно, порезались, очищая кожуру несуществующего яблока).
- Если яблок больше, чем наших команд обработки – часть продуктов пропала бы необработанной.
- Подобный «код» тяжело читать, в нём много повторов, его трудно модифицировать.
Циклы – операторы многократного выполнения действий
Цикл while Java (цикл вайл) хорошо подойдёт в нашем случае. Эта конструкция оформляет многократные действия в лаконичную и понятную структуру. Алгоритм по нарезке яблок для пирога в виде while в Java мог бы выглядеть как:
while(числоЯблокВТазике>0) { яблоко = тазик.взятьОчередноеЯблоко(); положитьВПирог(яблоко.чистить().нарезать()); числоЯблокВТазике–;//– это декремент, уменьшает количество яблок на единицу } System.out.ln(‘Яблоки для пирога обработаны.’);
Синтаксис команды
Первый способ описания оператора while следующий:
while(Логическое выражение) { // Тело цикла – периодически выполняемые оператор(ы) }
Выполняется следующим образом (по шагам):
- Вычисляем Логическое условие, следующее в скобках за while.
- Если логическое условие истинно, то выполняются операторы в теле цикла, после выполнения последнего оператора в теле цикла, переходим на шаг 1
- Если логическое условие ложно, то переходим к первому оператору за пределами цикла while.
Цикл с предусловием
Так как перед выполнением тела цикла мы всегда предварительно вычисляем логическое выражение (условие входа в цикл), то этот вид while часто называют циклом с предусловием. Построим таблицу первых десяти целых, положительных степеней числа:
public ic void main(String[] args) { int number = 3; // Возводимое в степень число int result = 1; // Результат возведения в степень int power = 1; // Начальный показатель степени while(power <= 10) { // условие входа в цикл result = result * number; System.out.ln(number + ” в степени ” + power + ” = ” + result); power++; } }
Результат вывода на консоль:
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
Цикл с постусловием
Второй вид цикла:
do { // Тело цикла – периодически выполняемые оператор(ы) }while (Логическое выражение);
Выполняется следующим образом (шаги):
- Выполняется тело цикла (сразу после ключевого слова do).
- Вычисляем Логическое условие, следующее в скобках за while.
- Если логическое условие истинно, то переходим на шаг 1
- Если логическое условие ложно, то переходим к первому оператору за пределами цикла while.
Два основных отличия от предыдущего вида цикла: тело цикла как минимум выполняется один раз и логическое условие проверяется после выполнения тела цикла. Поэтому этот вид цикла while называют циклом с постусловием. На этот раз выведем таблицу степеней числа, не превышающую 10000:
public ic void main(String[] args) { int number = 3;// Возводимое в степень число int result = number;// Результат возведения в степень int power = 1;// Начальный показатель степени do { System.out.ln(number + ” в степени ” + power + ” = ” + result); power++; result = result * number; }while (result < 10000); // условие выхода из цикла
Результат вывода на консоль:
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
Обратите внимания на изменения в коде, сравнив с вариантом цикла с предусловием.
Интересные факты о работе с циклами
Управляющие команды в теле цикла
Существуют две команды, влияющие на ход выполнения цикла: break, особенности применения которого мы покажем в следующей главе, и
continue.
- continue – прекращает выполнение тела текущего цикла и осуществляет переход к логическому выражению оператора while. Если вычисленное выражение будет истинно – выполнение цикла будет продолжено.
- break – немедленно прекращает выполнение текущего цикла и осуществляет переход к первой команде за его пределами. Таким образом, выполнение текущего цикла прерывается. Подробнее мы рассмотрим её в следующей теме.
Вспомним про наш фруктовый пример. Если мы не уверены в качестве предложенных яблок, то могли бы изменить код с применением команды continue: while(числоЯблокВТазике>0) { яблоко = тазик.взятьОчередноеЯблоко(); числоЯблокВТазике–;//– это декремент, уменьшает количество яблок на единицу if (яблоко.плохое()) { // метод вернет true для гнилого и т.п. яблока яблоко.выкинутьВМусор(); continue; // продолжим цикл, перейдем к условию числоЯблокВТазике>0 } положитьВПирог(яблоко.чистить().нарезать()); } Конструкцию continue часто применяют, когда в теле цикла необходимо выполнять команды при наступлении некоторого условия, например, выполнить действия при срабатывании датчика в оборудовании (а иначе просто продолжить цикл считывания его показателей) или вычислить выражение только на определенных шагах цикла. Пример для последнего случая – вычисление в цикле while суммы кубов натуральных чисел, у которых квадрат меньше их количества: public ic void main(String[] args) { int sum = 0; // итоговая сумма int i = 0; // стартовое число ряда int count = 20; // количество чисел while(i<=count) { i++; // берем очередное число, i++ эквивалентно i=i+1 if (i*i=<count) // если квадрат числа меньше continue; // количества чисел – сумму не считаем // переходим к следующему числу в цикле sum += i*i*i; // иначе считаем сумму кубов чисел } // sum += i*i*i – форма записи, аналогичная sum = sum + i*i*i System.out.ln(sum);// печатаем результат }
Бесконечный цикл
Данные управляющие команды чаще всего находят применение в бесконечном цикле. Его так называют, потому что логическое условие выхода никогда не выполняется. В коде он выглядит примерно как: while(true) { // Тело цикла } В этом случае и пригодится применение команды break для организации выхода из него. Этот вид цикла имеет место при ожидании внешних условий, которые формируются за пределами логики тела цикла. Например, в играх, эмулирующих виртуальный мир вокруг героя (выход из цикла = выход из игры), операционных системах. Или при использовании алгоритмов, возможно, улучшающих результат с каждым последующим вызовом в цикле, но ограничивая их по времени или наступлению внешнего события (шашки, шахматы или предсказание погоды). Следует помнить, что в обычных условиях бесконечные циклы – одна из проблем неустойчивости программы. Для демонстрации вернёмся к степеням числа: public ic void main(String[] args) { int number = 3; // Возводимое в степень число int result = 1; // Результат возведения в степень int power = 1; // Начальный показатель степени while(true) { result = result * number; System.out.ln(number + ” в степени ” + power + ” = ” + result); power++; if (power>10) break; // выход из цикла } } Результат вывода на консоль: 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.
Получили цикл в цикле. Подобные конструкции весьма частые. Для завершающего примера построим таблицу умножения, которые школьники 90-х видели на обложках тетрадей в младших классах.
public ic void main(String[] args) { // Выводим значения второго множителя в строке System.out.ln(” 2 3 4 5 6 7 8 9″); int i = 2; // первый множитель, присваиваем стартовое значение while(i<10) { // Первый цикл, выполняем пока первый множитель меньше 10 System.out.(i + ” | “);// Выводим первый множитель в начало строки int j = 2; // второй множитель, стартовое значение while (j<10) { // Второй цикл, выполняем пока второй множитель меньше 10 int mul=i*j; // Считаем произведение множителей if (mul<10) // Если содержит одну цифру-после него выводим два пробела System.out.(mul + ” “); else // иначе выводим произведение и после него – один пробел System.out.(mul + ” “); j++; // Увеличиваем на единицу второй множитель, } // Переходим к началу второго цикла (while (j<10 )…. ) System.out.ln(); // Перейдем на следующую строку вывода i++; // Увеличиваем на единицу первый множитель, } // Перейдем к началу первого цикла (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 Циклы (в частности, оператор while) – один из фундаментальных кирпичиков построения программ. Решая задачи на JavaRush, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.
Источник
Цикл Java While Do – это инструкция, позволяющая запускать один и тот же фрагмент кода несколько раз. Этот цикл можно использовать для повторения действий при соответствии условий.
Цикл while является самым простым для построения на языке Java. Он состоит из ключа while, условия loop, а также тела цикла:
while (condition) { // loop body }
Каждый отдельный запуск тела цикла расценивается как итерация. Перед каждой итерацией производится оценка условий цикла. Его тело исполняется, только если условия цикла по результатам оценки равно true.
Итерации цикла что-то меняют, и в определенный момент оценка условий возвращает false, после чего цикл завершается. Цикл, условие которого никогда не возвращает false, исполняется бесконечное количество раз. Такие циклы называются бесконечными.
Пример
int num = 0; while (num < 10) { System.out.ln(num); num++; }
Этот пример выводит числа от 0 до 9. Давайте пошагово пройдёмся по коду. Сначала мы инициализируем переменную num со значением равным 0. Это будет счётчик цикла. Когда программа доходит до while, производится оценка выполнения условий цикла. В нашем случае 0 < 10 возвращает значение true и исполняется тело цикла. Внутри цикла выводится переменная num, а затем увеличивается на 1. На этом завершается первая итерация.
После первого «прогона» условие цикла While Java оценивается во второй раз. 1 < 10 по-прежнему возвращает true, после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз.
Завершающая итерация начинается, когда значение num равняется 9. Счётчик цикла выводится в последний раз, и значение увеличивается до 10. На этот раз новая итерация не может быть запущена, так как условие цикла выдаёт значение false. Так как 10 не меньше 10.
Таким образом, цикл запускается до тех пор, пока условием цикла выполняется. Вооружившись этим знанием, можно создавать более сложные и функциональные циклы. Давайте проведёт итерацию с массивом:
String[] names = {“Doc”, “Dopey”, “Bashful”, “Grumpy”, “Sneezy”, “Sleepy”, “Happy”}; int index = 0; while (index < names.length) { System.out.ln(names[index]); index++; }
Концепция этого примера схожа с предыдущим. Мы инициализируем счётчик цикла и запускаем итерацию по массиву до тех пор, пока выводятся все элементы. В результате, итерация по массивам – довольно распространённый случай, и в Java для этого есть более подходящая конструкция – цикл For.
Цикл Java while do похож на while, но имеет существенное отличие: в отличие от while, здесь условие проверяется по окончании каждой итерации. Это значит, что цикл do-while всегда исполняется хотя бы один раз:
do { // loop body } while (condition);
Пример
do-while сначала исполняет тело цикла, а затем оценивает его условия. В зависимости от полученного результата цикл останавливается или запускается следующая итерация. Давайте рассмотрим простую игру «угадай имя»:
Scanner scanner = new Scanner(System.in); String guess; do { System.out.(“Угадай имя: “); guess = scanner.nextLine(); } while (!”Daffy Duck”.equals(guess)); System.out.ln(“Поздравляю! Ты угадал моё имя!”);
В этом while Java примере используется Scanner для парсинга ввода из system.ini. Это стандартный канал ввода, который в большинстве случаев взаимодействует с клавиатурой. Проще говоря, мы просто читаем текст, который вводит игрок.
В игре необходимо спросить пользователя хотя бы раз, и делать это до тех пор, пока игрок вводит правильные ответы. Цикл do-while идеально подходит для таких случаев. В теле цикла мы получаем пользовательское значение, а затем проводится проверка правильности ответа. Цикл должен запускаться до тех пор, пока вводимое пользователем значение не становится равным Daffy Duck. Если правильный ответ получен, цикл останавливается, и мы поздравляем игрока с победой.
Циклы while true Java позволяют использовать фрагменты кода несколько раз. Сегодня мы познакомились с циклами Java while и do-while. Они похожи тем, что проверяют условия и исполняют тело цикла, если по результатам оценки условия получено значение true. Но при этом у них есть существенное отличие: условие цикла while проверяется до итерации, а условие цикла do-while – по окончании каждой итерации. Это значит, что цикл do-while всегда исполняется как минимум один раз.
Данная публикация является переводом статьи «Java’s While and Do-While Loops in Five Minutes» , подготовленная редакцией проекта.
Источник
Как в Java создавать циклы и управлять ими. Как с их помощью автоматизировать обработку массивов и генерацию объектов.
https://d2xzmw6cctk25h.cloudfront.net/post/1238/og_cover_image/ed12996e6ef61b13a868df82b32b1e6c
Цикл – это блок команд, который выполняется снова и снова, пока соблюдается определённое условие. Повторяемый фрагмент кода называют «телом цикла». Одно выполнение тела цикла называют итерацией.
В Яве можно работать с циклами нескольких типов – для этого есть следующие операторы:
while – цикл с предусловием – сначала проверяем условие, затем выполняем тело цикла;
do… while – цикл с постусловием – сначала выполняем один раз тело цикла, затем проверяем условие и, если оно соблюдается, продолжаем;
for – цикл со счётчиком – выполняется и при каждой итерации обновляет счётчик, пока условие в объявлении цикла соблюдается (т.е. проверка условия возвращает true);
сокращенный for (в других языках известен как foreach) – перебирает массив от первого элемента до последнего и на каждой итерации выполняет тело цикла.
Суть условия цикла – проверка выражения с одной или несколькими переменными: «Пока a<11, в каждой итерации выполняем тело цикла и увеличиваем “а” на 1». Но чему равно «а» при первом выполнении цикла?
Если мы используем конструкции с while, значение нужно указать перед началом цикла:
int a = 1;
while (a < 11) {
System.out.ln(a);
a++; //увеличиваем а на единицу
}
Если же переменная работает как счётчик цикла, а за его пределами не используется, её инициализируют прямо в условии. И тут же пишут, что с ней делать в конце каждой итерации. Всё это – в одну строку – с помощью for:
for (а=1, a<11, i++) {
System.out.ln(a);
}
Получаем тот же результат. Список можно было начать с нуля или с отрицательного значения – диапазон определяем сами.
Сокращенный вариант цикла for не содержит указаний ни на число повторов, ни на действия в конце шага. Цикл типа foreach используют для перебора массивов. От первого элемента нужно переходить к следующему – пока массив не кончится.
int[] ms = { 1, 2, 3, 4}; //создаем массив
int s = 0;
for(int i : ms) { //указываем, что перебирать
s *= i; //последовательно перемножаем элементы
}
System.out.ln(s);
Вложенные циклы Java
Циклы можно вкладывать один в другой. При этом число повторов наружного и вложенных циклов умножается. Если внешний должен выполняться 5 раз и внутренний – 5, всего цикл будет выполнен 25 раз.
Выведем таблицу умножения с помощью двух массивов:
int a, b, result = 0;
for (a = 2; a < 10; a++) {
for (b = 2; b < 10; b++) {
result = a*b;
System.out.ln(a+”x”+b+” = “+result);
}
}
Cоздание объектов в цикле Java
Циклы удобны, когда нужно создать и пронумеровать множество объектов. Их число бывает неизвестно заранее: объекты могут создаваться по запросу пользователя. Вот мы спросили, сколько нужно чего-то, и записали число в переменную n. Теперь создадим объекты в нужном количестве:
Something[] array = new Something[n]; //создаем массив типа “что-то” из n элементов
for(int i = 0; i < n; i++){
array[i] = new Something(); //создаем “что-то” и помещаем его в массив
}
Как выйти из цикла Java
Для выхода из цикла есть ключевые слова break – «прервать», continue – «возобновить» и return – «вернуться». Команда break переключает программу на выполнение следующих за циклом операторов. Условия прерывания цикла в Java оформляют через if-ветвление. Главное, чтобы проверка выполнялась перед основной частью тела цикла.
//после создания массива m пишем:
for (a : m) {
if (a==5) break;
System.out.ln(a);
}
Операторы ветвления и цикла в Java часто работают вместе: запускаем цикл, а внутри него проверяем, не выполнено ли еще условие, при котором нужно прервать цикл или сделать что-то ещё.
Если использовать break во вложенном цикле, прервётся только он, а внешний продолжит выполняться.
Для досрочного прерывания итерации цикла for в Java используют continue. Когда программа до него доходит, она пропускает невыполненную часть итерации, обновляет счётчик и переходит к следующей итерации.
В конструкциях while тот же continue работает иначе: возвращает нас к проверке условия продолжения цикла. Другая команда – return – возвращает программу к месту, откуда был вызван метод, в котором цикл находится.
И continue, и break можно использовать с меткой – для перехода к нужной части кода – по аналогии с goto:
break Mark1; //при условии, что где-то выше стоит метка Mark1 :
Бесконечный цикл Java
Создать бесконечный цикл легко – достаточно не указывать параметры в for:
for (; 😉 {}
Сложнее извлечь из этого пользу. Обычно бесконечность цикла – критическая ошибка, которая мешает выполнению программы. Поэтому каждый цикл стоит проверять на способность корректно завершиться в нужный момент. Для этого нужно:
- указать в теле цикла условия прерывания,
- убедиться, что переменная в условии прерывания может принять значение, при котором цикл будет остановлен.
Советуем также посмотреть мастер-класс по созданию приложения “Погода”, где рассматривается работа с циклами
Источник