Короткая запись цикла for java. Циклы в Java
Надо обработать много однотипных данных? Надо вычислить ряд? Надо перемножить матрицы? Все это и намного больше поможет сделать цикл! 🙂 Все вычислительные системы изначально задумывались для того чтобы облегчить обработку данных. А обработку большого количества данных невозможно даже представить без циклов.
Вообще циклы в программировании принято разделять на три группы. Первая группа — это циклы со счетчиком. В них тело цикла выполняется некоторое количество раз, изначально заданное программистом. Такой цикл, обязательно выполнится заданное количество раз. Вторая группа — это циклы с предусловием. В них тело цикла выполняется только после проверки какого-то условия и будет выполняться до тех пор, пока это условие верно. Такие циклы могут не выполниться ни разу (если условие изначально ложно). И третья группа циклов — циклы с постусловием. В них сначала выполняется тело цикла, затем проверяется условие. Такой цикл выполнится как минимум один раз.
Начнем, пожалуй, с цикла со счетчиком. В 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
условие проверяется перед выполнением цтела цикла, то здесь условие проверяется уже после того как выполнится тело цикла. А это значит, что цикл выполнится как минимум один раз до того как проверится условие. Цикл for
Начиная с версии JDK 5, в Java существуют две формы цикла for. Первая - традиционная форма, используемая начиная с исходной версии Java. Вторая - новая форма "for-each". Мы рассмотрим оба типа цикла for, начиная с традиционной формы. Общая форма традиционного оператора for выглядит следующим образом: for(инициализация; условие; повторение) Если в цикле будет повторяться только один оператор, фигурные скобки можно опустить. Цикл for действует следующим образом. При первом запуске цикла программа выполняет инщиализационную часть цикла. В общем случае это выражение, устанавливающее значение управляющей переменной цикла, которая действует в качестве счетчика, управляющего циклом. Важно понимать, что выражение инициализации выполняется только один раз. Затем программа вычисляет условие, которое должно быть булевским выражением. Как правило, выражение сравнивает значение управляющей переменной с целевым значением. Если это значение истинно, программа выполняет тело цикла. Если оно ложно, выполнение цикла прерывается. Затем программа выполняет часть повторение цикла. Обычно это выражение, которое увеличивает или уменьшает значение управляющей переменной. Затем программа повторяет цикл, при каждом прохождении вначале вычисляя условное выражение, затем выполняя тело цикла и выполняя выражение повторения. Процесс повторяется до тех пор, пока значение выражения повторения не станет ложным. Ниже приведена версия программы подсчета "тактов", в которой использован цикл for. // Демонстрация использования цикла for. Объявление управляющих переменных цикла внутри цикла for
Часто переменная, которая управляет циклом for, требуется только для него и не используется нигде больше. В этом случае переменную можно объявить внутри инициали-зационной части оператора for. Например, предыдущую программу можно переписать, объявляя управляющую переменную л типа int внутри цикла for: // Объявление управляющей переменной цикла внутри цикла for. При объявлении переменной внутри цикла for необходимо помнить о следующем важном обстоятельстве: область и время существования этой переменной полностью совпадают с областью и временем существования оператора for. (То есть область существования переменной ограничена циклом for.) Вне цикла for переменная прекратит свое существование. Если управляющую переменную цикла нужно использовать в других частях программы, ее нельзя объявлять внутри цикла for. В тех случаях, когда управляющая переменная цикла не требуется нигде больше, большинство программистов Java предпочитают объявлять ее внутри оператора for. В качестве примера приведем простую программу, которая проверяет, является ли введенное число простым. Обратите внимание, что управляющая переменная цикла i объявлена внутри цикла for, поскольку она нигде больше не требуется. Разновидности цикла for
Цикл for поддерживает несколько разновидностей, которые увеличивают его возможности и повышают применимость. Гибкость этого цикла обусловлена тем, что его три части: инициализацию, проверку условий и итерационную не обязательно использовать только по прямому назначению. Фактически каждый из разделов оператора for можно применять в любых целях. Рассмотрим несколько примеров. Одна из наиболее часто встречающихся вариаций предполагает использование условного выражения. В частности, это выражение не обязательно должно выполнять сравнение управляющей переменной цикла с каким-либо целевым значением. Фактически условием, управляющим циклом for, может быть любое булевское выражение. Например, рассмотрим следующий фрагмент: boolean done = false; В этом примере выполнение цикла 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 }; При каждом прохождении цикла переменной х автоматически присваивается значение, равное значению следующего элемента массива nums. Таким образом, на первой итерации х содержит 1, на второй - 2 и т.д. При этом не только упрощается синтаксис программы, но и исключается возможность ошибок выхода за пределы массива. Ниже показан пример полной программы, иллюстрирующей применение описанной версии "for-each" цикла for. // Использование цикла for в стиле for-each. Значение равно: 1 Как видно из этого вывода, оператор for в стиле "for-each" автоматически выполняет цикл по элементам массива, от наименьшего индекса к наибольшему. Хотя повторение цикла for в стиле "for-each" выполняется до тех пор, пока не будут обработаны все элементы массива, цикл можно прервать и раньше, используя оператор break. Например, следующая программа суммирует значения пяти первых элементов массива nums. // Использование оператора break в цикле for в стиле for-each. Программа генерирует следующий вывод: Значение равно: 1 Как видите, выполнение цикла прекращается после получения значения пятого элемента. Оператор break можно использовать также и с другими циклами Java. Подробнее этот оператор будет рассмотрен в последующих разделах настоящей главы. При использовании цикла в стиле "for-each" необходимо помнить о следующем важном обстоятельстве. Его итерационная переменная является переменной "только для чтения", поскольку она связана только с исходным массивом. Операция присваивания значения итерационной переменной не оказывает никакого влияния на исходный массив. Иначе говоря, содержимое массива нельзя изменять, присваивая новое значение итерационной переменной. Например, рассмотрим следующую программу: // Переменная цикла for-each доступна только для чтения. Первый цикл for увеличивает значение итерационной переменной на 10. Однако эта операция присваивания не оказывает никакого влияния на исходный массив nums, как видно из результата выполнения второго оператора for. Генерируемый программой вывод подтверждает сказанное: 1 2 3 4 5 6 7 8 9 10 Итерация в многомерных массивах
Усовершенствованная версия цикла for применима также и к многомерным массивам. Однако следует помнить, что в Java многомерные массивы состоят из массивов массивов. (Например, двумерный массив - это массив одномерных массивов.) Это важно при выполнении итерации в многомерном массиве, поскольку результат каждой итерации - следующий массив, а не отдельный элемент. Более того, тип итерационной переменной цикла for должен быть совместим с типом получаемого массива. Например, в случае двумерного массива итерационная переменная должна быть ссылкой на одномерный массив. В общем случае при использовании цикла "for-each" для выполнения итерации в массиве размерности N получаемые объекты будут массивами размерности N-1. Дабы понять, что из этого следует, рассмотрим следующую программу. В ней вложенные циклы for служат для получения упорядоченных по строкам элементов двумерного массива. // Использование цикла for в стиле for-each применительно к двумерному массиву. Эта программа генерирует следующий вывод: Значение равно: 1 Следующая строка этой программы заслуживает особого внимания: for (int х : nums) { Обратите внимание на способ объявления переменной х. Эта переменная - ссылка на одномерный массив целочисленных значений. Это необходимо потому, что результат выполнения каждой итерации цикла for - следующий массив в массиве nums, начиная с массива, указанного элементом nums . Затем внутренний цикл for выполняет итерацию по каждому из этих массивов, отображая значения каждого из элементов. Использование усовершенствованного цикла for
Поскольку каждый оператор for в стиле "for-each" может выполнять цикл по элементам массива только последовательно, начиная с первого и заканчивая последним, может показаться, что его применение ограничено. Однако это не так. Множество алгоритмов требуют использования именно этого механизма. Одним из наиболее часто используемых алгоритмов является поиск. Например, следующая программа использует цикл for для поиска значения в неупорядоченном массиве. Поиск прекращается после обнаружения искомого значения. // Поиск в массиве с применением цикла for в стиле for-each. В данном случае выбор стиля "for-each" для цикла for полностью оправдан, поскольку поиск в неупорядоченном массиве предполагает последовательный просмотр каждого из элементов. (Конечно, если бы массив был упорядоченным, можно было бы использовать бинарный поиск, реализация которого требовала бы применения другого стиля цикла.) К другим типам приложений, которым применение циклов в стиле "for-each" предоставляет преимущества, относятся вычисление среднего значения, отыскание минимального или максимального значения в наборе, поиск дубликатов и т.п. В этом уроке мы узнаем, как повторно выполнять части нашего кода контролируемым образом, глядя на различные типы циклов в Java
. Подробнее познакомимся с циклами: while
, do-
while
, for
. Постараемся определить в каких случаях, какой из циклов наиболее пригоден для использования. Затем мы кратко рассмотрим тему случайных чисел (random
numbers
). Посмотрим на Java
-класс Random
и как он нам может помочь в нашей игре. Цикл как следует из названия – это способ выполнения одной и той же части кода необходимое количество раз (при этом результат выполнения кода в цикле необязательно будет повторяться). Количество повторений выполнения цикла может быть, как определенно заранее, так и быть неизвестным самому программисту. Мы рассмотрим основные типы циклов, которыми нам предлагает воспользоваться язык Java.
А после внедрим некоторые из них в нашу игру тем самым усовершенствовав её. Цикл 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++; //Я буду становиться очень большим!
}
А вдруг нам действительно понадобится воспользоваться бесконечным циклом, но так чтобы мы могли решить в какой момент из него выйти. Для этой цели в 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
действует почти так же, как и 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
всегда будет выполняться хотя бы один раз. Взгляните на пример: Int x = 0;
do {
x++;
} while(x < 10);
//x теперь = 10
Ключевые слова break,
continue
Цикл for
имеет более сложный синтаксис, чем while
и do-
while
, поскольку для его инициализации требуется немного больше манипуляций. Давайте сначала взглянем на него и потом разберём по частям: For(int i = 0; i < 10; i++){
//Что-то, что должно произойти 10 раз будет записано здесь
}
Как это видит компилятор? Вот так: For(объявление и инициализация; условие; изменить после каждого прохождения цикла){
// тело цикла
}
Ключевые слова break,
continue
также можно использовать в данном цикле. Цикл for
берёт на себя управление инициализацией, проверкой условия и изменением переменной. Испробуем на практике в нашем приложении данный цикл сразу же после того, как ознакомимся со случайными числами
и методами.
Последнее обновление: 31.10.2018 Еще одним видом управляющих конструкций являются циклы. Циклы позволяют в зависимости от определенных условий выполнять определенное действие множество раз.
В языке Java есть следующие виды циклов: Цикл 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 сначала выполняет код цикла, а потом проверяет условие в инструкции 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 сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется: Int j = 6;
while (j > 0){
System.out.println(j);
j--;
}
Оператор break
позволяет выйти из цикла в любой его момент, даже если цикл не закончил свою работу: Например: < nums.length; i++){
if (nums[i] > 10)
break;
System.out.println(nums[i]);
}
Так как в цикле идет проверка, больше ли элемент массива 10, то мы не увидим на консоли последние два элемента, так как когда
nums[i] окажется больше 10 (то есть равно 12), сработает оператор break, и цикл завершится. Правда, мы также не увидим и последнего элемента, который меньше 10. Теперь сделаем так, чтобы если число больше 10, цикл не завершался, а просто переходил к следующему элементу.
Для этого используем оператор continue
: Int nums = new int { 1, 2, 3, 4, 12, 9 };
for (int i = 0; i < nums.length; i++){
if (nums[i] > 10)
continue;
System.out.println(nums[i]);
}
В этом случае, когда выполнение цикла дойдет до числа 12, которое не удовлетворяет условию проверки, то программа просто пропустит это число и перейдет к следующему элементу массива. Как в практически любом языке программирования, в Java имеются инструменты, предназначенные для многократного повторения определенного фрагмента кода. Такие инструменты принято называть циклами. В Java циклы представлены такими операторами, как 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 }
{ // тело
}
class ForTick {
int n;
for(n=10; n>0; n-)
}
}
class ForTick (public static void main(String args) {
//в данном случае переменная n объявляется внутри цикла for
for(int n=10; n>0; n-)
System.out.println("такт " + n) ;
}
}
for(int i=1; !done; i++) {
// ...
if(interrupted()) done = true;
}
// ...
}
блок-операторов
int sum = 0;
for(int x: nums) sum += x;
class ForEach {
public static void main(String args) {
int sum = 0;
// использование стиля for-each для отображения и суммирования значений
for(int х: nums) {
sum += x;
}
System.out.println ("Сумма равна: " + sum) ;
}
}
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Значение равно: 6
Значение равно: 7
Значение равно: 8
Значение равно: 9
Значение равно: 10
Сумма равна: 55
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);
}
}
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Сумма пяти первых элементов равна: 15
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 ();
}
}
1 2 3 4 5 6 7 8 9 10
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);
}
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Значение равно: 2
Значение равно: 4
Значение равно: 6
Значение равно: 8
Значение равно: 10
Значение равно: 3
Значение равно: 6
Значение равно: 9
Значение равно: 12
Значение равно: 15
Сумма: 9 0
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("Значение найдено!");}
Цикл While
Выход их цикла. Ключевое слово break
Ключевое слово continue
Цикл do-while
Цикл for
for(int i = 10; i > 0; i--){
//обратный отсчет
}
//ключ на старт, i = 0
Цикл for
Цикл do
Цикл while
Операторы continue и break
