Циклы в Java – как создать и прервать. Циклы в Java: for, while, do-while
Последнее обновление: 31.10.2018
Еще одним видом управляющих конструкций являются циклы. Циклы позволяют в зависимости от определенных условий выполнять определенное действие множество раз. В языке Java есть следующие виды циклов:
Цикл for
Цикл for имеет следующее формальное определение:
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 — это цикл for; В общем виде его можно записать так:
For (Начальное условие; конечное условие; изменение) { тело цикла; }
Таким образом, если мы хотим выполнить какое-то действие 10 раз то мы должны записать следующее:
For (int i = 0; i<10; i++) { System.out.println(i); }
такая программа последовательно выведет на экран числа от нуля до девяти. Если чуть подробнее, то мы просто создаем новую переменную i и присваиваем ей начальное значение 0 (int i = 0;). Затем указываем, что цикл должен выполняться до тех пор, пока i < 10 и указываем каким образом должно изменяться i после каждой итерации цикла (i++).
Тех, кто программировал на паскале порадует такая возможность:
Int k = 15;
for (float i = 0; i В этом примере значение переменной i будет увеличиваться на 1,5 при каждой итерации. Можете проверить:). Следующий цикл на очереди — while
. Это цикл с предусловием и в общей форме его можно записать вот так: While(логическое выражение)
{
действия
}
Ну и если взять рабочий пример, то выглядеть он будет примерно так: While (a<10)
{
System.Out.Print(a);
a++;
}
Итак, понятно, что этот цикл имеет смысл использовать если вы точно не знаете сколько именно итераций необходимо для достижения цели, однако точно знаете условие при котором Ваша цель будет достигнута. Такая конструкция может не выполниться ни разу (ведь это цикл с предусловием)! Сколько раз выполнятся действия в цикле зависит от значения которое изначально было в переменной a
. И третий вид циклов — это циклы с постусловием. Он очень похож на while … do
только если в while … do
условие проверяется перед выполнением цтела цикла, то здесь условие проверяется уже после того как выполнится тело цикла. А это значит, что цикл выполнится как минимум один раз до того как проверится условие. Цикл Java While Do
– это инструкция, позволяющая запускать один и тот же фрагмент кода несколько раз. Этот цикл можно использовать для повторения действий при соответствии условий. Цикл 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
. Цикл 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
. Если правильный ответ получен, цикл останавливается, и мы поздравляем игрока с победой. Данная публикация представляет собой перевод статьи «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);
Циклы можно вкладывать один в другой. При этом число повторов наружного и вложенных циклов умножается. Если внешний должен выполняться 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);
}
}
Циклы удобны, когда нужно создать и пронумеровать множество объектов. Их число бывает неизвестно заранее: объекты могут создаваться по запросу пользователя. Вот мы спросили, сколько нужно чего-то, и записали число в переменную n. Теперь создадим объекты в нужном количестве: Something array = new Something[n]; //создаем массив типа “что-то” из n элементов
for(int i = 0; i < n; i++){
array[i] = new Something(); //создаем “что-то” и помещаем его в массив
}
Для выхода из цикла есть ключевые слова 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:
Создать бесконечный цикл легко - достаточно не указывать параметры в for: for (; ;) {}
Сложнее извлечь из этого пользу. Обычно бесконечность цикла – критическая ошибка, которая мешает выполнению программы. Поэтому каждый цикл стоит проверять на способность корректно завершиться в нужный момент. Для этого нужно: Рассмотрим 2 цикла: do-while и for. Скачать исходники для статьи можно ниже
Цикл do-while
Цикл do-while всегда выполняет свое тело по крайней мере один раз, потому что его условное выражение размещается в конце цикла. Общая форма цикла: Do {
// тело цикла
} while (condition);
Каждая итерация цикла do-while сначала выполняет тело цикла, а затем оценивает условное выражение. Если это выражение - true, цикл повторится. Иначе цикл заканчивается. Как и у всех Java-циклов, condition должно быть булевским выражением. // Демонстрирует do-while цикл.
public class DoWhile {
public static void main(String args) {
int n = 10;
do {
System.out.println("тик " + n);
n - -;
} while (n > 0);
}
}
Вывод программы: Цикл, for
Общая форма цикла for: For (initialization; condition; iteration) statement;
Если повторяется только один оператор, фигурные скобки не нужны. Ниже приводится программа вывода “тиков”, которая использует цикл for: // Демонстрирует for-цикл.
public class ForTick {
public static void main(String args) {
int n;
for (n = 10; n > Вывод программы: Объявление переменных управления внутри цикла for. // Определение переменной управления циклом внутри for.
public class ForTick {
public static void main(String args) {
// здесь n объявлена внутри заголовка for-цикла
for (int n = 10; n > 0; n - -) {
System.out.println("тик " + n);
}
}
}
Когда переменная объявляется внутри заголовка for-цикла, важно помнить, что область ее действия заканчивается там же, где и у for-оператора (т. е. область действия переменной ограничена циклом for). Вне цикла for переменная прекратит существование. Если нужно использовать управляющую переменную цикла в другом месте программы, ее не следует объявлять внутри цикла for. // Проверка на принадлежность к категории простых чисел.
public class FindPrim {
public static void main(String args) {
{
int num;
boolean isPrime = true;
num = 14;
for (int i = 2; i < num / 2; i++) {
if ((num % i) == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
System.out.println("Простое число");
} else {
System.out.println("Число не является простым");
}
}
}
}
Использование запятой Public class Sample {
public static void main(String args) {
int a, b;
b = 4;
for (a = 1; a < b; a++) {
System.out.println("a = " + a);
System.out.println("b = " + b);
b - -;
}
}
}
He трудно заметить, что цикл зависит от взаимодействия двух переменных. Так как цикл управляется двумя переменными, было бы полезно включить их непосредственно в заголовок оператора for вместо того, чтобы обрабатывать переменную вручную. К счастью, в Java обеспечена такая возможность. Чтобы позволить двум или большему числу переменных управлять циклом for, Java разрешает вам включать множественные операторы как в инициализационную, так и в итерационную части for-заголовка. Каждый оператор отделяется от следующего запятой. // Использование запятой.
public class Comma {
public static void main(String args) {
int a, b;
for (a = 1, b = 4; a < b; a++, b - -) {
System.out.println("а = " + a);
System.out.println("b = " + b);
}
}
}
В этом примере инициализационная часть устанавливает значения как для а, так и для b. Два разделенных запятыми оператора в итерационной части выполняются каждый раз, когда цикл повторяется. Программа генерирует следующий вывод: Замечание. В Java запятая - это разделитель, который применяется только в цикле for. Подобно всем другим языкам программирования Java допускает вложение циклов. То есть один цикл может быть внутри другого. Например, следующая программа вкладывает for-циклы: // Циклы могут быть вложенными.
public class Nested {
public static void main(String args) {
int i, j;
for (i = 0; i < 5; i++) {
for (j = i; j < 5; j++) {
System.out.print(".");
}
System.out.println();
}
}
}
Вывод этой программы: Приведем более внятный пример этой программы: Public class NestedArray {
public static void main(String args) {
int i, j;
for (i = 0; i < 5; i++) {
for (j = i; j < 5; j++) {
System.out.println("i = " + i + ",j = " + j);
}
}
}
}
Вывод этой программы В этом примере более наглядно видно, что на каждый вывод i, приходится 5 выводов j.Цикл While
Цикл do-while
В завершение
Циклы while true Java
позволяют использовать фрагменты кода несколько раз. Сегодня мы познакомились с циклами Java while
и do-while
. Они похожи тем, что проверяют условия и исполняют тело цикла, если по результатам оценки условия получено значение true
. Но при этом у них есть существенное отличие: условие цикла while
проверяется до итерации, а условие цикла do-while
– по окончании каждой итерации. Это значит, что цикл do-while
всегда исполняется как минимум один раз.
Вложенные циклы Java
Cоздание объектов в цикле Java
Как выйти из цикла Java
Бесконечный цикл Java
Ниже показана программы с “тиками”, которая демонстрирует цикл do-while.
тик 10
тик 9
тик 8
тик 7
тик 6
тик 5
тик 4
тик 3
тик 2
тик 1
Цикл for работает следующим образом. В начале работы цикла выполняется выражение initialization. В общем случае это выражение устанавливает значение переменной управления циклом, которая действует как счетчик. Важно понять, что выражение инициализации выполняется только один раз. Затем оценивается condition. Оно должно быть булевским выражением и обычно сравнивает переменную управления циклом с некоторым граничным значением. Если это выражение - true, то отрабатывают операторы из тела цикла, если - false, цикл заканчивается. Далее выполняется часть цикла iteration. Обычно это выражение, которое осуществляет инкрементные или декрементные операции с переменной управления циклом. Затем цикл реализовывает итерации. В каждом проходе цикла - сначала оценивается условное выражение, потом выполняется тело цикла и затем - выражение iteration. Этот процесс повторяется до тех пор, пока управляющее выражение не станет false.
тик 10
тик 9
тик 8
тик 7
тик 6
тик 5
тик 4
тик 3
тик 2
тик 1
Часто переменная, которая управляет циклом for, необходима только для целей цикла и не используется в другом месте. Когда дело обстоит так, можно объявить переменную внутри инициализационной части for. Например, предшествующая программа перекодирована так, чтобы переменная управления циклом n объявлялась типом int внутри заголовка for:
Когда управляющая переменная цикла не нужна где-то в другом месте, большинство Java-программистов объявляет ее внутри for-заголовка. Ниже показана небольшая программа, которая проверяет, является ли число простым (Простым называется число, которое делится только на собственное значение и на 1 (например, простыми являются числа 1, 2, 3, 5, 7, 11, 13 и т. д.). Обратите внимание, что управляющая переменная цикла i объявлена внутри for-заголовка, т. к. она нигде больше не нужна.
Может возникнуть желание включить более одного оператора в инициализационную и итерационную части цикла for. Например, рассмотрим цикл следующей программы:
Используя запятую, предыдущий цикл for можно закодировать более эффективно:
а = 1
b = 4
а = 2
b = 3
…..
….
…
..
.
i = 0,j = 0
i = 0,j = 1
i = 0,j = 2
i = 0,j = 3
i = 0,j = 4
i = 1,j = 1
i = 1,j = 2
i = 1,j = 3
i = 1,j = 4
i = 2,j = 2
i = 2,j = 3
i = 2,j = 4
i = 3,j = 3
i = 3,j = 4
i = 4,j = 4
