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

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

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 (; ;) {}

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

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

Последнее обновление: 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, которое не удовлетворяет условию проверки, то программа просто пропустит это число и перейдет к следующему элементу массива.

Начиная с версии 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 закончим.

Цикл for

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

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

for(инициализация; условие; повторение)
{ // тело
}

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

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

Ниже приведена версия программы подсчета "тактов", в которой использован цикл for.

// Демонстрация использования цикла for.
class ForTick {

int n;
for(n=10; n>0; n-)

}
}

Объявление управляющих переменных цикла внутри цикла for

Часто переменная, которая управляет циклом for, требуется только для него и не используется нигде больше. В этом случае переменную можно объявить внутри инициали-зационной части оператора for. Например, предыдущую программу можно переписать, объявляя управляющую переменную л типа int внутри цикла for:

// Объявление управляющей переменной цикла внутри цикла for.
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.

В тех случаях, когда управляющая переменная цикла не требуется нигде больше, большинство программистов Java предпочитают объявлять ее внутри оператора for. В качестве примера приведем простую программу, которая проверяет, является ли введенное число простым. Обратите внимание, что управляющая переменная цикла i объявлена внутри цикла for, поскольку она нигде больше не требуется.

Разновидности цикла for

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

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

boolean done = false;
for(int i=1; !done; i++) {
// ...
if(interrupted()) done = true;
}

В этом примере выполнение цикла for продолжается до тех пор, пока значение переменной done не будет установлено равным true. В этом цикле проверка значения управляющей переменной цикла i не выполняется.

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

for(; ;) {
// ...
}

Этот цикл может выполняться бесконечно, поскольку условие, по которому он был бы прерван, отсутствует. Хотя некоторые программы, такие как командные процессоры операционной системы, требуют наличия бесконечного цикла, большинство "бесконечных циклов" в действительности представляют собой всего лишь циклы с особыми условиями прерывания. Как вы вскоре убедитесь, существует способ прерывания цикла - даже бесконечного, подобного приведенному примеру - который не требует использования обычного условного выражения цикла.

Версия "for-each" цикла for

Начиная с версии JDK 5 в Java можно использовать вторую форму цикла for, реализующую цикл в стиле "for-each" ("для каждого"). Как вам, возможно, известно, в современной теории языков программирования все большее применение находит концепция циклов "for-each", которые быстро становится стандартными функциональными возможностями во многих языках. Цикл в стиле "for-each" предназначен для строго последовательного выполнения повторяющихся действий по отношению к коллекции объектов, такой как массив. В отличие некоторых языков, подобных С#, в котором для реализации циклов "for-each" используют ключевое слово f oreach, в Java возможность применения цикла "for-each" реализована за счет усовершенствования цикла for. Преимущество этого подхода состоит в том, что для его реализации не требуется дополнительное ключевое слово, и никакой ранее существовавший код не разрушается. Цикл for в стиле "for-each" называют также усовершенствованным циклом for. Общая форма версии "for-each" цикла for имеет следующий вид:

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

Здесь тип указывает тип, а итер-пер - имя итерационной переменной, которая последовательно будет принимать значения из коллекции, от первого до последнего. Элемент коллекция указывает коллекцию, по которой должен выполняться цикл. С циклом for можно применять различные типы коллекций, но в этой главе мы будем использовать только массивы. (Другие типы коллекций, которые можно применять с циклом for, вроде определенных в каркасе коллекций Collection Framework, рассматриваются в последующих главах книги.) На каждой итерации цикла программа извлекает следующий элемент коллекции и сохраняет его в переменной итер-пер. Цикл выполняется до тех пор, пока не будут получены все элементы коллекции.

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

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

int nums = { 1, 2, 3, 4, 5, б, 7, 8, 9, 10 };
int sum = 0;
for(int x: nums) sum += x;

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

Ниже показан пример полной программы, иллюстрирующей применение описанной версии "for-each" цикла for.

// Использование цикла for в стиле for-each.
class ForEach {
public static void main(String args) {

int sum = 0;
// использование стиля for-each для отображения и суммирования значений
for(int х: nums) {

sum += x;
}
System.out.println ("Сумма равна: " + sum) ;
}
}

Значение равно: 1
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Значение равно: 6
Значение равно: 7
Значение равно: 8
Значение равно: 9
Значение равно: 10
Сумма равна: 55

Как видно из этого вывода, оператор for в стиле "for-each" автоматически выполняет цикл по элементам массива, от наименьшего индекса к наибольшему.

Хотя повторение цикла for в стиле "for-each" выполняется до тех пор, пока не будут обработаны все элементы массива, цикл можно прервать и раньше, используя оператор break. Например, следующая программа суммирует значения пяти первых элементов массива nums.

// Использование оператора break в цикле for в стиле for-each.
class ForEach2 {
public static void main(String args) {
int sum = 0;
int nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// использование цикла for для отображения и суммирования значений
for(int х: nums) {
System.out.println("Значение равно: " + x) ;
sum += x; v if (x == 5) break; // прекращение цикла после получения 5 значений
}
System.out.println("Сумма пяти первых элементов равна: " + sum);
}
}

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

Значение равно: 1
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Сумма пяти первых элементов равна: 15

Как видите, выполнение цикла прекращается после получения значения пятого элемента. Оператор break можно использовать также и с другими циклами Java. Подробнее этот оператор будет рассмотрен в последующих разделах настоящей главы.

При использовании цикла в стиле "for-each" необходимо помнить о следующем важном обстоятельстве. Его итерационная переменная является переменной "только для чтения", поскольку она связана только с исходным массивом. Операция присваивания значения итерационной переменной не оказывает никакого влияния на исходный массив. Иначе говоря, содержимое массива нельзя изменять, присваивая новое значение итерационной переменной. Например, рассмотрим следующую программу:

// Переменная цикла for-each доступна только для чтения.
class NoChange {
public static void main(String args) {
int nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for(int х: nums) {
System.out.print (х + " ");
x=x*10; // этот оператор не оказывает никакого влияния на массив nums
}
System.out.println();
for(int x: nums)
System.out.print (x + " ");
System.out.println ();
}
}

Первый цикл for увеличивает значение итерационной переменной на 10. Однако эта операция присваивания не оказывает никакого влияния на исходный массив nums, как видно из результата выполнения второго оператора for. Генерируемый программой вывод подтверждает сказанное:

1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

Итерация в многомерных массивах

Усовершенствованная версия цикла for применима также и к многомерным массивам. Однако следует помнить, что в Java многомерные массивы состоят из массивов массивов. (Например, двумерный массив - это массив одномерных массивов.) Это важно при выполнении итерации в многомерном массиве, поскольку результат каждой итерации - следующий массив, а не отдельный элемент. Более того, тип итерационной переменной цикла for должен быть совместим с типом получаемого массива. Например, в случае двумерного массива итерационная переменная должна быть ссылкой на одномерный массив. В общем случае при использовании цикла "for-each" для выполнения итерации в массиве размерности N получаемые объекты будут массивами размерности N-1. Дабы понять, что из этого следует, рассмотрим следующую программу. В ней вложенные циклы for служат для получения упорядоченных по строкам элементов двумерного массива.

// Использование цикла for в стиле for-each применительно к двумерному массиву.
class ForEach3 {
public static void main(String args) {
int sum = 0;
int nums = new int ;
// присвоение значений элементам массива nums
for (int i = 0; i nums[i] [j] = (i+l)*(j+l) ; // использование цикла for в стиле for-each для отображения
// и суммирования значений
for (int х : nums) {
for(int у: х) {
System.out.println("Значение равно: " + у);
sum += у;
}
}
System.out.println("Сумма: " + sum);
}

Эта программа генерирует следующий вывод:

Значение равно: 1
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Значение равно: 2
Значение равно: 4
Значение равно: 6
Значение равно: 8
Значение равно: 10
Значение равно: 3
Значение равно: 6
Значение равно: 9
Значение равно: 12
Значение равно: 15
Сумма: 9 0

Следующая строка этой программы заслуживает особого внимания:

for (int х : nums) {

Обратите внимание на способ объявления переменной х. Эта переменная - ссылка на одномерный массив целочисленных значений. Это необходимо потому, что результат выполнения каждой итерации цикла for - следующий массив в массиве nums, начиная с массива, указанного элементом nums . Затем внутренний цикл for выполняет итерацию по каждому из этих массивов, отображая значения каждого из элементов.

Использование усовершенствованного цикла for

Поскольку каждый оператор for в стиле "for-each" может выполнять цикл по элементам массива только последовательно, начиная с первого и заканчивая последним, может показаться, что его применение ограничено. Однако это не так. Множество алгоритмов требуют использования именно этого механизма. Одним из наиболее часто используемых алгоритмов является поиск. Например, следующая программа использует цикл for для поиска значения в неупорядоченном массиве. Поиск прекращается после обнаружения искомого значения.

// Поиск в массиве с применением цикла for в стиле for-each.
class Search {
public static void main(String args) {
int nums = { 6, 8, 3, 7, 5, 6, 1, 4 };
int val =5;
boolean found = false;
// использование цикла for в стиле for-each
for (int x: nums) {
if (x == val) {
found = true;
break;
}
}
if(found)
System.out.println("Значение найдено!");}

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



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

В языке Java есть несколько способов создать циклы. Как Вы уже могли догадаться, мы будем рассматривать их все.

Первый способ объявить цикл — это использовать такую конструкцию: for (условие начала цикла; условие конца; шаг, с которым будет идти цикл) { тело цикла }

Перейдем сразу к примерам. Допустим у нас есть задача вывести фразу «привет мир» 10 раз. Если не использовать циклы, то можно просто написать System.out.println(«Привет мир»); десять раз и решим задачу. Давайте же для это цели используем циклы. Создайте новый класс и назовите его например CuclesInJava. Теперь объявите условие цикла (пусть это будет 0), условие конца — 10, и шаг. Будем идти с шагом в единицу. В тело цикла поместите строку System.out.println(«Привет мир»);

Вот пример кода:

Результатом такого кода будет 10 строк подряд фразы «Hello world!».

Как насчет написать что то более сложное. Мы уже выучили и базовые . Давайте их и используем.

Напишем простое приложение, которое будет выводить строку с оповещением каждый раз, когда шаг + некоторая переменная будет равна 5. У меня очень плохо с фантазией))

Для начала напишем код, который будет принимать на вход переменную введенную из консоли. В предыдущей статье, я давал пример этого кода и мы условились, что потом я объясню, как он работает и откуда пошел. А сейчас мы просто будем им пользоваться:

Далее нужно написать цикл, который будет начинаться с нуля и считать до десяти (как в предыдущем примере). В тело цикла запишем условный оператор, который будет проверять, является эта переменная равна 5 и если это так, то будем выводить строку «ОК». Вот, что у меня получилось:

import java.util.Scanner ;

1. public class CuclesInJava {

   int variable = scanner.nextInt () ; //мы дойдем до этого постепенно и тогда будет понятно, как это работает

2. for (int i = 1 ; i < 10 ; i++ ) {

   int newVariable = i + variable;

   if (newVariable== 5) {

Получилось не очень замысловато. Этим примером, я хотел показать, как можно использовать циклы с ветвлениями в связке.

Следующим способом объявить циклы является конструкция: while(условие истинно){блок кода, который нужно выполнить}. У данной конструкции есть другая форма:

do{блок кода, который нужно выполнить}while(условие истинно). Отличие первого от второго в том, что второе выполнить один цикл независимо истинно условие или нет. Можете сами подумать: сначала мы выполняем кода, а потом уже проверяем условие. И даже если условие будет не истинным, код все равно выполниться один раз, в том время, когда в первом виде конструкции сначала проверяется условие и пока оно не будет истинным, код не выполнится.

Код должен быть интуитивно понятен. Думаю, стоит упомянуть, что с помощью конструкций while и do-while можно «зациклить» программу если не прописать или неправильно прописать условие выхода из цикла. Посмотрите на пример выше и подумайте, что было, если бы я написал не i—, а i++; или вместо i>0, i<0. Моя программа никогда не вышла бы из цикла и продолжала бы выводить строку Hello world! до тех пор, пока не завис компьютер. Поэтому, будьте очень осторожными с циклами и всегда следите, чтобы из них Ваша программа могла выйти или закончить работу.

Ну и пример с do-while:

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