Цикл 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 ” был подготовлен дружной командой проекта .

Цикл - это блок команд, который выполняется снова и снова, пока соблюдается определённое условие. Повторяемый фрагмент кода называют «телом цикла». Одно выполнение тела цикла называют итерацией.

В Яве можно работать с циклами нескольких типов - для этого есть следующие операторы:

while – цикл с предусловием – сначала проверяем условие, затем выполняем тело цикла;

do… while – цикл с постусловием – сначала выполняем один раз тело цикла, затем проверяем условие и, если оно соблюдается, продолжаем;

for – цикл со счётчиком – выполняется и при каждой итерации обновляет счётчик, пока условие в объявлении цикла соблюдается (т.е. проверка условия возвращает true);

сокращенный for (в других языках известен как foreach) – перебирает массив от первого элемента до последнего и на каждой итерации выполняет тело цикла.

Суть условия цикла – проверка выражения с одной или несколькими переменными: «Пока a<11, в каждой итерации выполняем тело цикла и увеличиваем "а" на 1». Но чему равно «а» при первом выполнении цикла?

Если мы используем конструкции с while, значение нужно указать перед началом цикла:

int a = 1;

while (a < 11) {

System.out.println(a);

a++; //увеличиваем а на единицу

}

Если же переменная работает как счётчик цикла, а за его пределами не используется, её инициализируют прямо в условии. И тут же пишут, что с ней делать в конце каждой итерации. Всё это – в одну строку – с помощью for:

for (а=1, a<11, i++) {

System.out.println(a);

}

Получаем тот же результат. Список можно было начать с нуля или с отрицательного значения – диапазон определяем сами.

Сокращенный вариант цикла for не содержит указаний ни на число повторов, ни на действия в конце шага. Цикл типа foreach используют для перебора массивов. От первого элемента нужно переходить к следующему – пока массив не кончится.

int ms = { 1, 2, 3, 4}; //создаем массив

int s = 0;

for(int i: ms) { //указываем, что перебирать

s *= i; //последовательно перемножаем элементы

}

System.out.println(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.println(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.println(a);

}

Операторы ветвления и цикла в Java часто работают вместе: запускаем цикл, а внутри него проверяем, не выполнено ли еще условие, при котором нужно прервать цикл или сделать что-то ещё.

Если использовать break во вложенном цикле, прервётся только он, а внешний продолжит выполняться.

Для досрочного прерывания итерации цикла for в Java используют continue. Когда программа до него доходит, она пропускает невыполненную часть итерации, обновляет счётчик и переходит к следующей итерации.

В конструкциях while тот же continue работает иначе: возвращает нас к проверке условия продолжения цикла. Другая команда – return – возвращает программу к месту, откуда был вызван метод, в котором цикл находится.

И continue, и break можно использовать с меткой - для перехода к нужной части кода - по аналогии с goto:

break Mark1; //при условии, что где-то выше стоит метка Mark1:

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

Создать бесконечный цикл легко - достаточно не указывать параметры в for:

for (; ;) {}

Сложнее извлечь из этого пользу. Обычно бесконечность цикла – критическая ошибка, которая мешает выполнению программы. Поэтому каждый цикл стоит проверять на способность корректно завершиться в нужный момент. Для этого нужно:

• указать в теле цикла условия прерывания,
• убедиться, что переменная в условии прерывания может принять значение, при котором цикл будет остановлен.

Начиная с версии JDK 5, в Java существуют две формы цикла for. Первая — традиционная форма, используемая начиная с исходной версии Java. Вторая — новая форма “for-each”. Мы рассмотрим оба типа цикла for, начиная с традиционной формы.

Общая форма традиционного оператора for выглядит следующим образом:

Если в цикле будет повторяться только один оператор, фигурные скобки можно опустить.

Цикл for действует следующим образом. При первом запуске цикла программа выполняет инициализационную часть цикла. В общем случае это выражение, устанавливающее значение управляющей переменной цикла, которая действует в качестве счетчика, управляющего циклом. Важно понимать, что выражение инициализации выполняется только один раз . Затем программа вычисляет условие , которое должно быть булевским выражением. Как правило, выражение условия сравнивает значение управляющей переменной с целевым значением. Если это значение истинно, программа выполняет тело цикла. Если оно ложно, выполнение цикла прерывается . Затем программа выполняет тело цикла и только после этого выполняется часть повторение цикла . Повторение это обычно выражение, которое увеличивает или уменьшает значение управляющей переменной. Затем программа повторяет цикл, при каждом прохождении вначале вычисляя условное выражение, затем выполняя тело цикла и выполняя выражение повторения . Процесс повторяется до тех пор, пока значение выражения условия не станет ложным.

Поскольку большинство циклов применяют свои переменные только внутри цикла, цикл for допускает, чтобы выражение инициализации было полным объявлением переменной. Таким образом, переменная ограничена телом цикла и невидима извне .

Приведем пару примеров поясняющих все вышесказанное:

В этом примере переменная i объявлена вне цикла (строка 7), поэтому она так же доступна после его завершения (строка 12).

Из вывода выполнения данной программы видно, что выражение повторения цикла, а именно префиксный инкремент (++i ) переменной i выполняется после выполнения тела цикла, то есть после выполнения строки 10, которая выводит приветствие.

Этот момент очень важно понимать, чтобы иметь правильное представление о работе цикла for .

Теперь посмотрим на вывод этой программы с аргументами командной строки и без них:

Как видно из вывода данной программы приращение переменной i происходит после выполнения последней команды цикла, которая выводит приветствие (строка 10).

А теперь объявим переменную внутри цикла (оператора for):

Как видно Eclipse нам сразу же указал на ошибку, что переменная j , объявленная в строке 15, не видна вне цикла, так как ее область действия или область видимости распространяется только на тело цикла, в котором она была объявлена.

Чтобы программа заработала необходимо закомментировать строку 19.

Вывод этого кода, аналогичен выводу, кода который мы только что рассмотрели, за исключением того, что вместо “Привет” выводится “Hello”. Ну и то что после цикла не возможно вывести значение переменной j .

При объявлении переменной внутри цикла for необходимо помнить о следующем важном обстоятельстве: область и время существования этой переменной полностью совпадают с областью и временем существования оператора for .

Синтаксис цикла for не ограничивается циклами с единственной переменной. Как в выражении инициализации , так и в выражении повторения можно использовать запятую для разделения нескольких выражений инициализации и повторения .

Например:

В этом примере в инициализационной части цикла мы устанавливаем начальные значения обеих управляющих переменных a и b . Оба разделенных запятой оператора в итерационной части выполняются при каждом повторении цикла.

Данный код генерирует следующий вывод:

Цикл for поддерживает несколько разновидностей, которые увеличивают его возможности и повышают применимость. Гибкость этого цикла обусловлена тем, что его три части: инициализацию , проверку условий и итерационную не обязательно использовать только по прямому назначению. Фактически каждый из разделов оператора for можно применять в любых целях . Например:

Пример конечно немного головоломный, но по сути он прост. Первая часть оператора инициализирует переменную b , вторая ее проверяет, а третья выводит на консоль сообщение.

По существу эта программа делает то же приветствие аргументов, если они есть. Если их нет, то ни чего не выводит. Сразу же приведу пример ее вывода:

Как видно из вывода этой программы, итерационная часть выполняется, как уже и говорилось, после выполнения тела цикла. В данном случае это оператор println в строке 9. Оператор for в данном коде растянулся на две строки 9 и 10, поскольку он достаточно длинный. Я это сделал для демонстрации того, что каждая часть оператора for может быть применена в разных целях. Стоит еще заметить, что приращение переменной i происходит в строке 12 и там же задается условие для продолжения или выхода из цикла, которое проверяется в строке 9.

Еще один подобный пример, цикл for можно задействовать для прохождения по элементам связного списка:

Стоит, так же, отметить, что любую из частей цикла for (инициализацию , условие и итерационную ) или даже все можно пропустить . Например, можно создать таким образом бесконечный цикл:

Инициализационное или итерационное выражения либо они оба могут отсутствовать:

В этом примере инициализационное и итерационное выражения вынесены за пределы определения оператора for . В результате соответствующие части оператора for пусты.

Чтобы последовательность выполнения частей оператора for стала более наглядный я приведу небольшой пример. Хотя методы мы еще не изучали, но я надеюсь идея этой программы будет вам понята. Смысл ее в том, чтобы наглядно показать последовательность выполнения всех частей оператора for.

Из вывода программы видно, что инициализационная часть программы (метод initTest() ) выполняется только один раз.

Затем выполняется проверка условия , представленная методом condTest() .

После проверки условия , выполняется тело цикла.

И уже после этого выполняется часть повторение , представленная методом recTest() .

В методе condTest() выполняется проверка условия продолжения цикла. В данном случае переменная i сравнивается c 4, и пока переменная i меньше 4, то тело цикла выполняется.

Тело цикла выполняется четыре раза так как переменная i была по умолчанию проинициализирована нулем.

Оператор foreach

Начиная с версии JDK 5 в Java можно использовать вторую форму цикла for, реализующую цикл в стиле foreach (“для каждого”). Цикл в стиле foreach предназначен для строго последовательного выполнения повторяющихся действий по отношению к коллекциям объектов, например, таких как массивы. В Java возможность применения цикла foreach реализована за счет усовершенствования цикла for . Общая форма версии foreach цикла for имеет следующий вид:

for (тип итерационная переменная: коллекция) блок-операторов

Тип это тип переменной, итерационная переменная — имя итерационной переменной, которая последовательно будет принимать значения из коллекции , от первого до последнего. Элемент коллекция указывает коллекцию, по которой должен выполняться цикл. С циклом for можно применять различные типы коллекций, но пока мы будем использовать только массивы, кстати которые тоже пока не проходили, но по крайней мере уже было много примеров с приветствиями из массива строк, куда попадают аргументы командной строки.

На заметку: оператор foreach применим к массивам и классам, реализующим интерфейс java.lang.Iterable.

На каждой итерации цикла программа извлекает следующий элемент коллекции и сохраняет его в итерационной переменной. Цикл выполняется до тех пор, пока не будут получены все элементы коллекции.

Хотя повторение цикла for в стиле foreach выполняется до тех пор, пока не будут обработаны все элементы массива (коллекции), цикл можно прервать и раньше, используя оператор break .

Поскольку итерационная переменная получает значения из коллекции, ее тип должен совпадать (или быть совместимым) с типом элементов, хранящихся в коллекции. Таким образом, при выполнении цикла по массивам тип должен быть совместим с базовым типом массива.

Чтобы понять побудительные причины применения циклов в стиле foreach , рассмотрим тип цикла for , для замены которого предназначен этот стиль.

Возьмем опять наш пример с приветствием аргументов из командной строки:

Не правда ли, это куда элегантней, чем применение других операторов цикла, для этой цели?

Собственно у этой программы простой вывод:

Мы его уже много раз видели в разных вариантах, но повторенье – мать ученья.

Для полной ясности рассмотрим еще несколько примеров.

При каждом прохождении цикла переменной x автоматически присваивается значение, равное значению следующего элемента массива nums. Таким образом, на первой итерации x содержит 1, на второй — 2 и т.д. При этом упрощается синтаксис программы, и исключается возможность выхода за пределы массива.

Вывод этой части программы такой:

Хотя повторение цикла for в стиле foreach выполняется до тех пор, пока не будут обработаны все элементы массива, цикл можно прервать и раньше, используя оператор break . Например:

В данном примере цикл отработает только три итерации, после чего произойдет выход из цикла по условию оператора if , который вызовет срабатывание оператора break .

Важно, так же, понимать, что итерационная переменная получает значения из коллекции (массива), на каждой итерации, поэтому, даже если ее значение изменить в теле цикла, то на следующей итерации она снова примет следующее значение из коллекции. И тем более ее изменения ни как не влияют на значения коллекции (элементы массива в данном примере).

Данный код выведет следующее:

Любой метод, возвращающий массив, может использоваться с foreach . Например класс String содержит метод toCharArray, возвращающий массив char. Пример:

Данный код просто выведет посимвольно строку Привет Мир!

На этом с данными операторами можно закончить. Единственное что стоит еще упомянуть, это то, что в инициализационной части можно объявлять только переменные одного типа, или же инициализировать переменные разных типов, но такие которые могут быть приведены к одному общему типу по правилу приведения типов, которые мы рассматривали раньше.

На последок, приведу еще пару примеров продвинутого оператора for . По большому счету, это просто отрефактореный код того примера что я уже приводил.

Не правда ли, что этот код стал более читаем и понятен, чем тот, что я уже приводил? Или же не понятно? Ну тогда смотрим на другой пример кода, который делает тоже самое.

Неужели опять не понятно?

Оба этих кода делают одинаковый вывод:

Конечно при условии что аргументами в командной строке были Вася и Петя.

На этом с оператором for и его тенью foreach закончим.

Цикл — это многократно повторяющийся фрагмент программы.

В java существует два типа циклов: типа «пока» и типа «n-раз».

Первый тип «пока» предназначен для повторения какого-то действия до тех пор, пока выполняется некоторое условие. Пример: увеличивать число на 5 до тех пор, пока оно не станет трёхзначным.

Второй тип «n-раз» предназначен для повторения каких-то действий заранее известное количество раз. Пример: умножить число само на себя 4 раза.

Цикл типа «пока» (операторы while и do…while)

Оператор while повторяет указанные действия до тех пор, пока его параметр имеет истинное значение.

Например, такой цикл выполнится 4 раза, а на экран будет выведено «1 2 3 4 »:

Int i = 1; while (i < 5) { System.out.print(i + " "); i++; }

Такой цикл не выполнится ни разу и на экран ничего не выведется:

Int i = 1; while (i < 0) { System.out.print(i + " "); i++; }

Такой цикл будет выполняться бесконечно, а на экран выведется «1 2 3 4 5 6 7 …»:

Int i = 1; while (true) { System.out.print(i + " "); i++; }

Условие, определяющее будет ли цикл повторятся снова, проверяется перед каждым шагом цикла, в том числе перед самым первым. Говорят, что происходит предпроверка условия.

Бывает цикл типа «пока» с постпроверкой условия. Для его записи используется конструкция из операторов do…while.

Такой цикл выполнится 4 раза, а на экран будет выведено «2 3 4 5 »:

< 5);

Такой цикл выполнится 1 раз, а на экран будет выведено «2 »:

Int i = 1; do { i++; System.out.print(i + " "); } while (i < 0);

Тело цикла do…while выполняется по крайней мере один раз. Этот оператор удобно использовать, когда некоторое действие в программе нужно выполнить по крайней мере единожды, но при некоторых условиях придётся повторять его многократно.

Ознакомьтесь со следующей программой (она загадывает случайное целое число из отрезка и просит пользователя его угадать, вводя варианты с клавиатуры, пока пользователь не угадает число, программа будет ему подсказывать, сообщая больше или меньше число загаданное, чем то, что ввёл пользователь):

Import java.util.Scanner; public class Main { public static void main(String args) { // prog - число созданное программой // user - число введённое пользователем int prog, user; // Генерируем случайное целое число от 1 до 10 prog = (int)(Math.random() * 10) + 1; System.out.println("Я загадала число от 1 до 10, отгадайте его."); System.out.print("Вводите ваше число: "); Scanner input = new Scanner(System.in); // Проверяем, есть ли в потоке ввода целое число if(input.hasNextInt()) { do { // Читаем с потока ввода целое число user = input.nextInt(); if(user == prog) { System.out.println("Вы угадали!"); } else { // Проверяем, входит ли число в отрезок if (user > 0 && user <= 10) { System.out.print("Вы не угадали! "); // Если число загаданное программой меньше... if(prog < user) { System.out.println("Моё число меньше."); } else { System.out.println("Моё число больше."); } } else { System.out.println("Ваше число вообще не из нужного отрезка!"); } } } while(user != prog); } else { System.out.println("Ошибка. Вы не ввели целое число!"); } System.out.println("До свиданья!"); } }

Внесите в программу следующие доработки:

Программа должна загадывать число не из отрезка , а целое число из отрезка от [−10;10], исключая ноль. При этом, постарайтесь, чтобы распределение случайных чисел генерируемых программой было равномерных (т. е. в случае выпадения нуля его нельзя просто заменить на какое-то другое число, например, на 1, ведь тогда 1 будет выпадать с вдвое большей вероятностью, чем остальные числа).

Программа должна подсказывать пользователю, что он ошибся в знаке, если программа загадала положительное число, а пользователь ввёл отрицательное. И наоборот.

Цикл типа «n-раз» (оператор for)

Оператор for содержит три параметра. Первый называется инициализацией, второй — условием повторения, третий — итерацией.

For (инициализация; условие; итерация) { //тело цикла, т. е. действия повторяемые циклично }

В первом параметре обычно выбирают какую-то переменную, с помощью которой будет подсчитываться количество повторений цикла. Её называют счетчиком. Счётчику задают некоторое начальное значение (указывают, начиная с какого значения он будет изменяться).

Во втором параметре указывают некоторое ограничение на счётчик (указывают, до какого значения он будет изменяться).

В третьем параметре указывают выражение, изменяющее счётчик после каждого шага цикла. Обычно это инкремент или декремент, но можно использовать любое выражение, где счётчику будет присваиваться некоторое новое значение.

Перед первым шагом цикла счётчику присваивается начальное значение (выполняется инициализация). Это происходит лишь однажды.

Перед каждым шагом цикла (но после инициализации) проверяется условие повторения, если оно истинно, то в очередной раз выполняется тело цикла. При этом, тело цикла может не выполниться ни разу, если условие будет ложным в момент первой же проверки.

После завершения каждого шага цикла и перед началом следующего (и, значит, перед проверкой условия повторения) выполняется итерация.

Представленная программа выводит на экран числа от 1 до 100:

For (int i = 1; i <= 100; i++) { System.out.print(i + " "); }

Представленная программа выводит на экран числа от 10 до −10:

For (int s = 10; s > -11; s--) { System.out.print(s + " "); }

Представленная программа выводит на экран нечётные числа от 1 до 33:

For (int i = 1; i <= 33; i = i + 2) { System.out.print(i + " "); }

Представленная программа вычислит сумму элемнтов фрагмента последовательности 2, 4, 6, 8,… 98, 100. Итак:

Int sum = 0; // Сюда будем накапливать результат for (int j = 2; j

Представленная программа будет возводить число из переменной a в натуральную степень из переменной n :

Double a = 2; int n = 10; double res = 1; // Сюда будем накапливать результат for (int i = 1; i <= n; i++) { res = res * a; } System.out.println(res);

Представленная программа выведет на экран 10 первых элементов последовательности 2n+2, где n=1, 2, 3…:

For (int i = 1; i < 11; i++) { System.out.print(2*i + 2 + " "); }

Представленная программа выведет на экран 10 первых элементов последовательности 2a n−1 +3, где a 1 =3:

Int a = 3; for (i=1; i<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }

В одном цикле можно задавать сразу несколько счётчиков. При этом несколько выражений в итерации и в инициализации разделяются запятыми. Условие повторения можно задавать только одно, но оно может быть выражением, содержащим сразу несколько счётчиков.

Представленная программа выведет на экран 10 первых элементов последовательности 2a n−1 -2, где a 1 =3:

For (int a=3, i=1; i<=10; a=2*a-2, i++) { System.out.print(a + " "); }

Представленная программа выведет на экран такую последовательность «0 -1 -4 -9 -16 -25»:

For (int a=0, b=0; a-b<=10; a++, b--) { System.out.print(a*b + " "); }

Досрочное завершение цикла (оператор break)

Как цикл типа «пока» так и цикл типа «n-раз» можно завершить досрочно, если внутри тела цикла вызвать оператор break . При этом произойдёт моментальный выход из цикла, не будет закончен даже текущий шаг (т. е. если после break присутствовали какие-то ещё операторы, то они не выполнятся).

В результате работы следующего примера на экран будут выведены только числа «1 2 3 4 Конец»:

For (int a=1; a

Когда программа будет выполнять цикл в пятый раз(войдёт в цикл с счётчиком равным 5), сразу же будет проверено и окажется истинным условие при котором выполнится оператор break. Оставшаяся часть тела цикла (вывод на экран) уже производится не будет: программа сразу перейдёт к выполнению операций указанных после цикла и далее.

C помощью оператор break можно прервать заведомо бесконечный цикл. Пример (на экран выведется «100 50 25 12 6 3 1 0 » и после этого цикл остановится):

Int s = 100; while (true) { System.out.print(s + " "); s = s / 2; if(s == 0) { break; } }

Оператор break имеет смысл вызывать только при наступлении какого-то условия, иначе цикл будет завершен досрочно на первом же своём шаге.

Int a; for (a=25; a>0; a--) { break; System.out.print(a + " "); } System.out.print("a=" + a);

В представленном выше примере вывода в цикле на экран не произойдёт ни разу, а когда переменная a выведется на экран после цикла, то окажется, что её значение ни разу не менялось, т. е. выведено будет «a=25» (и ничего больше).

Обратите внимание также на то, что переменная была объявлена до начала цикла. Когда переменная объявляется в параметрах цикла, то она оказывается недоступной за его приделами, а в данном случае требовалось иное — узнать какое значение будет у счётчика после завершенияцикла.

Задачи

Создайте программу, выводящую на экран все четырёхзначные числа последовательности 1000 1003 1006 1009 1012 1015 ….

Создайте программу, выводящую на экран первые 55 элементов последовательности 1 3 5 7 9 11 13 15 17 ….

Создайте программу, выводящую на экран все неотрицательные элементы последовательности 90 85 80 75 70 65 60 ….

Создайте программу, выводящую на экран первые 20 элементов последовательности 2 4 8 16 32 64 128 ….

Выведите на экран все члены последовательности 2a n-1 -1, где a 1 =2, которые меньше 10000.

Выведите на экран все двузначные члены последовательности 2a n-1 +200, где a 1 = -166.

Создайте программу, вычисляющую факториал натурального числа n, которое пользователь введёт с клавиатуры.

Выведите на экран все положительные делители натурального числа, введённого пользователем с клавиатуры.

Проверьте, является ли введённое пользователем с клавиатуры натуральное число — простым. Постарайтесь не выполнять лишних действий (например, после того, как вы нашли хотя бы один нетривиальный делитель уже ясно, что число составное и проверку продолжать не нужно). Также учтите, что наименьший делитель натурального числа n, если он вообще имеется, обязательно располагается в отрезке .

Создайте программу, выводящую на экран 12 первых элементов последовательности 2a n-2 -2, где a 1 =3 и a 2 =2.

Выведите на экран первые 11 членов последовательности Фибоначчи. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий — сумме двух предыдущих.

Для введённого пользователем с клавиатуры натурального числа посчитайте сумму всех его цифр (заранее не известно сколько цифр будет в числе).

В городе N проезд в трамвае осуществляется по бумажным отрывным билетам. Каждую неделю трамвайное депо заказывает в местной типографии рулон билетов с номерами от 000001 до 999999. «Счастливым» считается билетик у которого сумма первых трёх цифр номера равна сумме последних трёх цифр, как, например, в билетах с номерами 003102 или 567576. Трамвайное депо решило подарить сувенир обладателю каждого счастливого билета и теперь раздумывает, как много сувениров потребуется. С помощью программы подсчитайте сколько счастливых билетов в одном рулоне?

В городе N есть большой склад на котором существует 50000 различных полок. Для удобства работников руководство склада решило заказать для каждой полки табличку с номером от 00001 до 50000 в местной типографии, но когда таблички напечатали, оказалось что печатный станок из-за неисправности не печатал цифру 2, поэтому все таблички, в номерах которых содержалась одна или более двойка (например, 00002 или 20202) — надо перепечатывать. Напишите программу, которая подсчитает сколько всего таких ошибочных табличек оказалось в бракованной партии.

Электронные часы показывают время в формате от 00:00 до 23:59. Подсчитать сколько раз за сутки случается так, что слева от двоеточия показывается симметричная комбинация для той, что справа от двоеточия (например, 02:20, 11:11 или 15:51).

В американской армии считается несчастливым число 13, а в японской — 4. Перед международными учениями штаб российской армии решил исключить номера боевой техники, содержащие числа 4 или 13 (например, 40123, 13313, 12345 или 13040), чтобы не смущать иностранных коллег. Если в распоряжении армии имеется 100 тыс. единиц боевой техники и каждая боевая машина имеет номер от 00001 до 99999, то сколько всего номеров придётся исключить?

2010, Алексей Николаевич Костин. Кафедра ТИДМ математического факультета МПГУ.