В 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 соответственно. Для лучшего понимания рекомендуем проделать упражнения с применением данных операторов в различных формах, а также различных способов их прерывания и перехода из одного блока в другой.

В этом уроке мы узнаем, как повторно выполнять части нашего кода контролируемым образом, глядя на различные типы циклов в Java . Подробнее познакомимся с циклами: while , do- while , for . Постараемся определить в каких случаях, какой из циклов наиболее пригоден для использования.

Затем мы кратко рассмотрим тему случайных чисел (random numbers ). Посмотрим на Java -класс Random и как он нам может помочь в нашей игре.

Цикл как следует из названия – это способ выполнения одной и той же части кода необходимое количество раз (при этом результат выполнения кода в цикле необязательно будет повторяться). Количество повторений выполнения цикла может быть, как определенно заранее, так и быть неизвестным самому программисту. Мы рассмотрим основные типы циклов, которыми нам предлагает воспользоваться язык Java. А после внедрим некоторые из них в нашу игру тем самым усовершенствовав её.

Цикл While

Цикл while имеет самый простой синтаксис. Вспомните if -инструкцию, которую мы изучали чуть ранее. В условное выражение оператора if (то, что заключено в скобочки после слова if ) можно поместить практически любую комбинацию операторов и переменных. Если выражение будет истинным (true ), то код, заключенный в тело блока if будет выполнен. Аналогичным образом в цикле while мы помещаем выражение, которое может вычисляться в true или false , как показано в этом коде:

Int x = 10; while(x > 0){ x--; //x уменьшается на один каждый проход цикла }

Что здесь происходит? Первым делом за пределами цикла while мы объявили переменную x типа int и присвоили этой переменной значение “10”. Далее начинается цикл while , в условии которого написано “ x > 0” – это означает, что код, написанный в теле цикла while будет выполняться до тех пор, пока переменная x больше 0 и условие не достигнет значения false . Следовательно, код выполнится 10 раз(x=10,x>0 ; x=9,x>0 ; x=8,x>0 ; x=7,x>0 ; x=6,x>0 ; x=5,x>0 ; x=4,x>0 ; x=3,x>0 ; x=2,x>0 ; x=1,x>0). В первый проход цикла x = 10 , во второй уже 9 , в третий 8 и т.д. И когда x будет равен 0 , то условие захода в цикл не выполнится, и программа продолжится со следующей строки после окончания цикла.

Также, как и в операторе if , возможна такая ситуация, при которой цикл не будет выполнен ни разу. Взгляните на следующий пример:

Int x = 10; while(x > 10){ //какой-нибудь код //но он никогда не выполнится, пока x больше 10 }

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

Int playerLives = 3; int alienShips = 10; while(playerLives >0 && alienShips >0){ //Весь игровой код здесь //... //... // и т.д. } //программа продолжится здесь, когда или playerLives или alienShips = 0

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

Стоит отметить, что как только программа входит в тело цикла, он будет выполнен, даже если условие цикла станет false , где-нибудь в теле цикла, т.к. условие проверяется только при входе:

Int x = 1; while(x > 0){ x--; //x теперь равен 0 и условие в следующий раз примет значение false //Но эта строка выполнится //И эта //И даже эта }

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

Int x = 0; while(true){ x++; //Я буду становиться очень большим! }

Выход их цикла. Ключевое слово break

А вдруг нам действительно понадобится воспользоваться бесконечным циклом, но так чтобы мы могли решить в какой момент из него выйти. Для этой цели в Java существует ключевое слово break . Мы можем использовать break , когда нам нужно будет «выйти» из цикла:

Int x = 0; while(true){ x++; //Я буду становиться очень большим! break; //Нет, не будешь! //код здесь не будет достигнут }

Наверняка вы уже догадались о том, что возможно сочетать различные инструменты принятия решений, такие как if, else, switch внутри нашего цикла while и других циклах, которые рассмотрим чуть ниже. К примеру:

Int x = 0; int tooBig = 10; while(true){ x++; //Я буду становиться очень большим! if(x == tooBig){ break; //Нет, не будешь. } //код здесь будет доступен до тех пор пока x не станет равен 10 }

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

Ключевое слово continue

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

Int x = 0; int tooBig = 10; int tooBigToPrint = 5; while(true){ x++; //Я буду становиться очень большим! if(x == tooBig){ break; } //Нет, не будешь. //код здесь будет доступен только пока x не станет равен 10 if(x >= tooBigToPrint){ //больше не будет выводиться на экран, но цикл будет продолжаться continue; } //код здесь будет доступен пока x не станет равен 5 //код для вывода x на экран }

Пояснение: объявляем и инициализируем переменные. Заходим в цикл — прибавляем к значению переменной x единицу (теперь x = 1). Проверка «1 равно 10?» — false — первый оператор if не выполняется. Следующая проверка «1 больше или равен 5?» — false — второй оператор if не выполняется. Выводим x на экран.

Рассмотрим вариант, когда x будет принимать значение 5 при входе в цикл. Заходим в цикл — прибавляем к значению переменной x единицу (теперь x = 6). Проверка «6 равно 10?» — false — первый оператор if не выполняется. Следующая проверка «6 больше или равен 5?» — true — заходим в тело if — continue , выходим из цикла и проверяем условие входа в цикл.

Теперь вариант, когда x будет принимать значение 9 при входе в цикл. Заходим в цикл — прибавляем к значению переменной x единицу (теперь x = 10). Проверка «10 равно 10?» — true — заходим в тело if — break , выходим из цикла и код продолжится за закрывающейся фигурной скобкой цикла while .

Цикл do-while

Почти тоже самое, что и предыдущий цикл за исключением одной особенности – проверка выполнения условного выражения будет происходить после тела цикла. Это означает, что цикл do- while всегда будет выполняться хотя бы один раз. Взгляните на пример:

Int x = 0; do { x++; } while(x < 10); //x теперь = 10

Ключевые слова break, continue

Цикл for

Цикл for имеет более сложный синтаксис, чем while и do- while , поскольку для его инициализации требуется немного больше манипуляций. Давайте сначала взглянем на него и потом разберём по частям:

For(int i = 0; i < 10; i++){ //Что-то, что должно произойти 10 раз будет записано здесь }

Как это видит компилятор? Вот так:

For(объявление и инициализация; условие; изменить после каждого прохождения цикла){ // тело цикла }

  • Объявление и инициализация – мы создали новую переменную типа int с именем i и присвоили ей значение 0 ;
  • Условие – подобно другим рассмотренным ранее циклам, тут мы проверяем условие вхождения в цикл. Если значение вычисляется как true , то входим в тело цикла;
  • Изменить после каждого прохождения цикла – в примере выше i ++ означает то, что после очередного прохода цикла мы к значению переменной i добавляем единицу (1). Более того, мы можем в изменении переменной написать и i — , чтобы отнимать единицу, например:
for(int i = 10; i > 0; i--){ //обратный отсчет } //ключ на старт, i = 0

Ключевые слова break, continue также можно использовать в данном цикле.

Цикл 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 имеются инструменты, предназначенные для многократного повторения определенного фрагмента кода. Такие инструменты принято называть циклами. В 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 ; //создаем массив типа “что-то” из 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 (; ;) {}

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

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