Зачем нужны циклы в java. Циклы в Java: for, while, do-while
12.08.17 1.9KЦикл Java While Do – это инструкция, позволяющая запускать один и тот же фрагмент кода несколько раз. Этот цикл можно использовать для повторения действий при соответствии условий.
Цикл While
Цикл while является самым простым для построения на языке Java . Он состоит из ключа while , условия loop , а также тела цикла:
while (condition) { // loop body }
Каждый отдельный запуск тела цикла расценивается как итерация. Перед каждой итерацией производится оценка условий цикла. Его тело исполняется, только если условия цикла по результатам оценки равно true .
Итерации цикла что-то меняют, и в определенный момент оценка условий возвращает false , после чего цикл завершается. Цикл, условие которого никогда не возвращает false , исполняется бесконечное количество раз. Такие циклы называются бесконечными.
Пример
int num = 0; while (num < 10) { System.out.println(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.println(names); index++; }
Концепция этого примера схожа с предыдущим. Мы инициализируем счётчик цикла и запускаем итерацию по массиву до тех пор, пока выводятся все элементы. В результате, итерация по массивам – довольно распространённый случай, и в Java для этого есть более подходящая конструкция – цикл For .
Цикл do-while
Цикл 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.print("Угадай имя: "); guess = scanner.nextLine(); } while (!"Daffy Duck".equals(guess)); System.out.println("Поздравляю! Ты угадал моё имя!");
В этом 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 (к сожалению, переставить за вас ящики Java не сможет), то получится запись в сто строк:
1. взять ящик №1 и поставить в другой угол;
2. взять ящик №2 и поставить в другой угол;
3. взять ящик №3 и поставить в другой угол;
…
100. взять ящик №100 и поставить в другой угол;
Сто строк кода – это уже много, но бывает тысяча, две, три и так далее. Для этих целей, а именно – упрощения записи повторяющихся действий и служат циклы.
Существует три оператора представляющих циклы в языке Java – это while, do/white и for. Каждый из операторов необходим в своей ситуации, но все же чаще всего используется оператор for. Рассмотрим по порядку каждый из операторов.
Оператор while
Синтаксическая запись оператора while выглядит следующим образом:
While(условие) { // действия }
Так же имеет место выполнение определенного предусловия, но в отличие от оператора if/else, данная конструкция построена на циклах проверки условия. Когда программа доходит до оператора while, если предложенное условие истинно, происходит выполнение всех действий в блоке из фигурных скобок {…}. После выполнения этих действий, программа снова делает очередную проверку условия после оператора while и если условие опять истинно, происходит повторное выполнение действий в блоке. Действия в блоке выполняются до тех пор, пока условие не станет ложным и только тогда происходит выход из цикла while.
Для выхода из циклов чаще всего используются так называемые счетчики. Рассмотрим не большой пример:
Int i = 0; while (i < 10) { // действия i++; }
Сначала переменной i присваивается значение 0, далее происходит проверка условия i0)
{ // действия i--; }
Те же действия, но уже в обратную сторону. Дополнительно в цикле while (да и вовсе других циклах) имеется возможность использования булевых переменных, содержащих значения false или true. В этом случае происходит проверка определенного предусловия.
Boolean i = true; while (i) { // действия }
Переменная i истинна, ей присвоено значение true, поэтому происходит выполнение цикла while, до тех пор пока переменной i не будет присвоено значение false. Поэтому необходимо позаботиться о выходе из такого цикла, иначе цикл while будет выполняться бесконечно и такие циклы носят названия бесконечных циклов.
Напоследок хочу еще обратить ваше внимание на оператор равно ==. Если записать цикл таким образом:
Int i = 0 while (i == 5) { // действия i++; }
То получится вполне работоспособный цикл, а вот если вы ошибетесь или по привычке воспользуетесь классическим вариантом оператора равно =, использующимся в математике, то у вас будет проблема в виде бесконечного цикла.
Int i = 0 while (i = 5) { // действия i++; }
В предусловии происходит присвоение переменной i значения 5, а это действие не запрещено и что мы имеем в итоге? Начнется выполнение этого блока цикла в конце которого значение i увеличится на один, но в предусловии после оператора while, переменной i новь будет присвоено значение пять и цикл продолжит свою работу до бесконечности. Это пример простого бесконечного цикла и как следствие, классическая ошибка, случающаяся очень часто с начинающими программистами.
Цикл do/while
Только что рассмотренный нами цикл while, при определенных условиях может и не заработать. Например, если условие будет изначально ложно, то цикл не выполнится ни разу. Программа, дойдя до строки кода с оператором while, проверит условие и если оно будет равно false, проигнорирует весь цикл и перейдет к коду, следующему сразу за циклом while. Но иногда возникает необходимость в выполнении цикла по крайней мере один раз. Для этих целей в Java существует цикл do/while. Запись и создание цикла do/while осуществляется следующим образом:
Do { // действия }while (условие)
Между операторами do и while существует тело цикла, которое будет выполняться до тех пор, пока постусловие, следующее за оператором while, не будет ложно. Тело цикла выполнится, по меньшей мере, один раз, после чего будет произведена проверка условия. Цикл do/while используется не часто, но порой оказывается незаменим.
Цикл for
Это самый распространенный цикл в программировании. Работа цикла for основан на управлении счетчиком. Смысл работы этого цикла схож с рассмотренными выше циклами while и do/while. Посмотрите как выглядит синтаксическая запись цикла for:
For (int i = 0; i < 10; i++) { // действие }
После ключевого слова for, следует условие выполнения цикла. Само же условие объединяет в себе три этапа. Сначала следует инициализация счетчика i = 0, затем проверка условия i < 10 и в конце увеличение переменной i на единицу.
Работает цикл for следующим образом. Когда программа доходит до цикла, то происходит инициализация счетчика i = 0 и проверяется условие i < 10. Далее программа переходит в тело цикла. По окончанию всех действий в цикле for, происходит обращение к третьему этапу цикла: i++, увеличивая счетчик на единицу. После чего сразу же происходит переход ко второму этапу – проверке переменной i < 10 и повторный выход в тело цикла. Весь цикл продолжается до тех пор, пока условие i < 10 не станет ложным. Цикл for используется постоянно при инициализации массива данных, где без него очень сложно, а порой и не возможно обойтись. Так же как и в цикле while возможно использование оператора декремента, например.
Как в практически любом языке программирования, в Java имеются инструменты, предназначенные для многократного повторения определенного фрагмента кода. Такие инструменты принято называть циклами. В Java циклы представлены такими операторами, как while и for, а также их разновидностями. Циклы, как правило, используются для прохода по одномерным и многомерным массивам и структурам данных для нахождения определенны элементов и дальнейших операций с ними. Но это далеко не единственный способ применения такого инструмента, как цикл Java. По мере их рассмотрения будут приводиться примеры использования.
Цикл while Java: описание и примеры
While является основополагающим оператором цикла в Java. Заключенный в его теле фрагмент кода будет повторяться до тех пор, пока условие выражения, заключенного в скобки после него, будет удовлетворять истинному значению. Оператор while в общем виде имеет следующий вид: while (условие){//тело цикла}. Как только значение логического условия перестанет быть истинным, код, заключенный в тело цикла, перестанет выполняться. Управление передастся строке, которая идет сразу после него. Если в теле цикла заключен всего один оператор, то можно не ставить фигурные скобки. Однако, среди программистов считается хорошим тоном всегда ставить их. Давайте разберем пример:
Public class whileDemo (
System.out.println (“Printing Numbers from 1 to 10”);
while (count<=10) {
System.out.println(count);
Изначально объявленная переменная count имеет значение 1. Далее мы видим логическое выражение, которое заключено в скобки после названия оператора. Если значение будет истинным, то цикл будет возвращать значение true до тех пор, пока значение переменной countне будет равно или меньше 10.С каждым проходом или итерацией значение переменной будет увеличиваться на 1 и выводится на консольный экран. Когда значение переменной достигло значения 11, цикл завершил работу. Если бы значение переменной count равнялось изначально 11, то тогда условие цикла было бы ложным. Программа даже не зашла бы в тело. Необходимо отметить, что синтаксис Java дает возможность использовать оператор While без тела. Рассмотрим следующий пример. Предположим, у вас есть две переменные: i=100 иj=200. Перед нами стоит задача вычислить программным путем их среднее арифметическое значение, для этой цели можно использовать «пустотелый» цикл while:
While (++i<- — j);
В результате данной операции значение любой из этих двух переменных будет равняться среднему от их начальных значений. Как можно увидеть в этом примере, цикл прекрасно работал без тела и выполнил в условном выражении все необходимые действия.
Цикл do-while
В предыдущих примерах если выражение условия возвращало значение false, то программа игнорировала тело цикла и продолжала дальнейшее выполнение. Но иногда возникают ситуации, когда выполнение кода, который содержится в теле цикла обязательно хотя бы один раз вне зависимости от истинности выражения условия. Иначе говоря, иногда бывает так, что необходимо проверять истинность условного выражения в начале, а не в конце цикла. Подобную функциональность может обеспечить разновидность цикла while с условным названием do-while. Он имеет такую форму: do {// тело цикла} while (условие). Как вы можете убедиться, сначала здесь идет выполнение тела цикла, а потом проверяется истинность условия. Так делается на каждой итерации. Приведенный выше код отработает примерно так же, как и в случае с while. Но если бы мы присвоили переменной count значение 11, тело цикла все равно выполнилось бы один раз, прежде чем оператор смог бы проверить истинность выражения.
Примеры и описание: for – Java цикл
Цикл for является универсальной и эффективной языковой формой в языке Java. Вплоть до пятой версии JavaSDK существовала только одна традиционная форма оператора for. После нее появилась новая – foreach. В этом разделе речь пойдет о традиционной форме оператора. Циклforвjava имеетследующийвид:
for (inti=0; i<10; i++) {//Loop statements to be executed
Прежде чем управление передастся коду в конце цикла, выполняется инициализация переменной i, которая выступает в качестве счетчика. Далее необходимо проверить условное выражение, в котором счетчик сравнивался с определенным значением. Если программа возвращает true, тело цикла выполняется. При этом значение счетчика меняется на заданный заранее шаг и снова проверяется условное выражение. Так происходит до тех пор, пока условие не станет ложным. Для лучшего понимания приведем пример того, как работает цикл for Java.
public class ForLoops {
public static void main (String args) {
intend_value =11;
for ; [условие]; [изменение счетчика]) { // действия }
Рассмотрим стандартный цикл for:
For (int i = 1; i < 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }
Первая часть объявления цикла - int i = 1 создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип int . Это может быть и любой другой числовой тип, например, float. Перед выполнением цикла значение счетчика будет равно 1. В данном случае это то же самое, что и объявление переменной.
Вторая часть - условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока i не достигнет 9.
И третья часть - приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i-- .
В итоге блок цикла сработает 8 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.
Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:
Int i = 1; for (; ;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }
Определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (; ;) . Теперь нет инициализированной переменной-счетчика, нет условия, поэтому цикл будет работать вечно - бесконечный цикл.
Либо можно опустить ряд блоков:
Int i = 1; for (; i<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }
Этот пример эквивалентен первому примеру: у нас также есть счетчик, только создан он вне цикла. У нас есть условие выполнения цикла. И есть приращение счетчика уже в самом блоке for.
Цикл for может определять сразу несколько переменных и управлять ими:
Int n = 10; for(int i=0, j = n - 1; i < j; i++, j--){ System.out.println(i * j); }
Цикл do
Цикл do сначала выполняет код цикла, а потом проверяет условие в инструкции while. И пока это условие истинно, цикл повторяется. Например:
Int j = 7; do{ System.out.println(j); j--; } while (j > 0);
В данном случае код цикла сработает 7 раз, пока j не окажется равным нулю. Важно отметить, что цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно. Так, мы можем написать:
Int j = -1; do{ System.out.println(j); j--; } while (j > 0);
Хотя переменная j изначально меньше 0, цикл все равно один раз выполнится.
Цикл while
Цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:
Int j = 6; while (j > 0){ System.out.println(j); j--; }
Операторы continue и break
Оператор break позволяет выйти из цикла в любой его момент, даже если цикл не закончил свою работу:
Например:
< nums.length; i++){ if (nums[i] > 10) break; System.out.println(nums[i]); }
Так как в цикле идет проверка, больше ли элемент массива 10, то мы не увидим на консоли последние два элемента, так как когда nums[i] окажется больше 10 (то есть равно 12), сработает оператор break, и цикл завершится.
Правда, мы также не увидим и последнего элемента, который меньше 10. Теперь сделаем так, чтобы если число больше 10, цикл не завершался, а просто переходил к следующему элементу. Для этого используем оператор continue :
Int nums = new int { 1, 2, 3, 4, 12, 9 }; for (int i = 0; i < nums.length; i++){ if (nums[i] > 10) continue; System.out.println(nums[i]); }
В этом случае, когда выполнение цикла дойдет до числа 12, которое не удовлетворяет условию проверки, то программа просто пропустит это число и перейдет к следующему элементу массива.
В Java, как и практически в любом языке программирования, имеются инструменты для обеспечения многократного повторения определенного фрагмента кода, или, как их принято называть, циклов. Циклы в Java представлены такими операторами, как for и while, а также их разновидностями. Как правило, циклы используются для прохода по одномерным и многомерным массивам и итерируемым структурам данных (в т.ч. коллекциям) с целью нахождения определенных элементов и дальнейших операций с ними. Однако это не единственный способ применения такого инструмента, как цикл Java. Примеры использования будут приводиться по мере их рассмотрения.
Java: описание и примеры
Основополагающим оператором цикла в Java является while. Фрагмент кода, заключенный в его теле, будет повторяться до тех пор, пока условие выражения, заключенного в скобки после него, будет удовлетворять логическому значению истинности. Общая форма оператора while имеет следующий вид:
while(условие) {
//тело цикла
Как только значение логического условия перестанет быть истинным, заключенный в тело цикла код перестанет выполняться и управление передастся идущей сразу после него строке.
Если в теле цикла заключен всего один оператор, то фигурные скобки можно не ставить, однако считается хорошим тоном, если они стоят всегда. На рисунке выше представлена блок-схема работы данного оператора.
Для наглядности давайте разберем пример, представленный на рисунке ниже:
Объявленная переменная count изначально имеет значение 1. Далее мы видим логическое выражение, заключенное в скобки после названия оператора. Оно будет истинным, т.е. возвращать значение true, до тех пор, пока значение переменной count будет меньше или равно 10. В теле цикла с каждым проходом (итерацией) значение переменной увеличивается на 1 и выводится на консольный экран. Обратите внимание на то, что когда значение переменной достигло 11, цикл прекратил работу.
Если бы значение переменной count изначально равнялось 11, то условие цикла было бы ложным, и программа даже не зашла бы в его тело.
Стоит отметить, что синтаксис Java позволяет использовать оператор while без тела. Приведем пример. Допустим, у нас есть две переменные i = 100 и j = 200, перед нами стоит задача программно вычислить их среднее арифметическое - для этого можно использовать «пустотелый» while:
while(++i < --j);
В результате значение любой из двух переменных будет равно среднему их изначальных значений. Как видите, цикл прекрасно отработал без тела и выполнил все необходимые действия в условном выражении.
Цикл do-while
В предыдущих примерах если условное выражение изначально возвращало значение false, то выполнение программы проигнорировало бы тело цикла и пошло дальше. Однако часто возникают ситуации, в которых выполнение кода, содержащегося в теле цикла, обязательно хотя бы единожды независимо от истинности условного выражения. Иными словами бывает так, что проверять истинность условного выражения требуется не в начале, а в конце цикла. Такую функциональность может обеспечить разновидность цикла while под названием do-while. Он имеет следующую форму:
do {
//тело цикла
} while(условие);
Как мы видим, сначала на выполнение идет тело цикла, и лишь потом проверяется истинность условия - и так каждую итерацию.
Код, приведенный выше, отработает примерно так же, как в случае с обычным while. Однако если бы мы присвоили переменной count значение 11, тело цикла все равно выполнилось бы один раз, перед тем как оператор смог проверить истинность выражения.
Описание и примеры for - Java цикл
Представляет собой универсальную и эффективную языковую форму в Java. До пятой версии Java SDK была только одна традиционная форма оператора for, а после появилась новая - for each. В данном разделе мы ознакомимся с традиционной формой оператора. for Java цикл имеет следующий вид:
Перед тем как управление передастся коду в теле цикла, сначала выполняется инициализация переменной i, выступающей в качестве счетчика. Далее проверяется условное выражение, в котором счетчик сравнивается с определенным значением, и если оно возвращает true, тело цикла выполняется. Затем значение счетчика изменяется на заранее заданный шаг и опять проверяется условное выражение, и так до тех пор, пока условие не станет ложным. Блок-схема ниже иллюстрирует все этапы работы цикла.
Для лучшего понимания приведем пример того, как работает for Java цикл:
Мы видим, что в качестве счетчика используется переменная loopVal. После каждой итерации цикла ее значение будет прирастать на 1, и это будет происходить до тех пор, пока оно не достигнет 11. Обратите внимание, что управляющую переменную можно объявлять и за пределами оператора for, но если вы не собираетесь использовать эту переменную нигде кроме как в цикле, рекомендуется объявлять ее непосредственно в операторе. Имейте в виду, что объявленная в самом операторе переменная имеет область видимости в пределах этого самого цикла.
Бывают ситуации, когда требуется объявить несколько управляющих циклом переменных. For Java цикл позволяет указывать две и более переменные через запятую, причем делать это как при их инициализации, так и при итерации. Такой оператор будет иметь следующий вид:
for(int i = 1, int j = 10; i < j; ++i, --j) {}
При каждой итерации значение переменной i будет увеличиваться на 1, а значение переменной j уменьшаться на 1. Итерации будут выполняться до тех пор, пока i не станет больше или равно j.
Особенности применения оператора for
Цикл for представляет собой довольно гибкую конструкцию, поскольку все три его части (инициализацию, условие и инкремент/декремент) можно использовать не по прямому назначению. К примеру, вместо условного выражения с управляющей переменной можно подставить любую логическую переменную.
boolean exit = false;
for (int i = 0; !exit; ++i) {
На примере выше мы можем наблюдать, как работа цикла абсолютно не зависит от управляющей переменной i и количество итераций зависит исключительно от того, в какой момент переменная exit примет значение true. Более того управляющую переменную можно и вовсе убрать из цикла и это никак не отразится на его работе: for(; !exit;) {}. Хотя это и не самый разумный способ программирования, иногда это может быть полезным. Главное - предусмотреть ситуацию, в которой переменная примет нужное для выхода из цикла значение, чтобы не превратить его в бесконечный.
For Java цикл может быть объявлен и таким способом: for(; ;) {}. Это типичный пример бесконечного цикла с особыми условиями прерывания. О том, каким же образом прерывать такого рода циклы, мы поговорим немного позже.
Цикл в стиле for each
Цикл foreach Java всегда применяется для последовательного перебора элементов массива или какой-либо и выполнения над ними определенных повторяющихся операций. Пример данной формы оператора for представлен ниже:
В качестве итерационной переменной объявляется name, а объявленный ранее массив строк names выступает вторым аргументом оператора. Переменная name будет поочередно принимать значения каждого элемента массива, пока все его элементы не будут извлечены. Следует отметить, что тип переменной должен быть совместимым с типом элементов, которые хранятся в массиве. Также переменная name доступна исключительно для чтения и попытка ее изменения не приведет к изменению самого элемента в массиве.
Операторы прерывания цикла
Существует три оператора прерывания цикла: break, return и continue. Первые два способны полностью прервать работу цикла, а continue прерывает лишь работу текущей итерации. Если вы используете в своем коде умышленно бесконечный цикл Java, данные операторы обязательно должны в нем присутствовать. Рассмотрим простой пример использования break:
Хотя в данном операторе for предусмотрено 11 итераций, выполнится только 8, поскольку, когда счетчик i будет равен 7, сработает условие, в теле которого имеется оператор break.
Оператор return действует аналогичным образом, с тем отличием, что он не только обеспечивает выход из цикла Java, но и из метода, в который помещен этот цикл.
Использование break в качестве goto
Следует иметь в виду, что break прерывает работу только того цикла, в теле которого он непосредственно находится, т.е. если вы используете его во вложенном цикле, то внешний цикл не прекратит своей работы. Для этого оператор break можно использовать в качестве цивилизованной формы goto.
В этом варианте данный оператор используется в связке с меткой, которая позволяет организовывать выход не только из циклов, но и из любого блока кода. Метка представляет собой именованный соответствующим образом идентификатор с двоеточием после него. Метка объявляется в начале помечаемого блока кода. Чтобы прервать выполнение помеченного блока, в нужном месте необходимо объявить: break имя_метки. Рассмотрим пример на рисунке ниже:
В коде объявлено три блока с именами меток One, Two и Three соответственно. Оператор break с меткой Two вложен во все три блока, но при его срабатывании программа выйдет из блоков Three и Two и продолжит выполнение в блоке One. Т.е. в консоли мы увидим два сообщения: Three и One.
Заключение
Мы ознакомились с понятием циклов в Java, главными операторами while и for, а также их формами do-while и for each соответственно. Для лучшего понимания рекомендуем проделать упражнения с применением данных операторов в различных формах, а также различных способов их прерывания и перехода из одного блока в другой.