Что является условием для выполнения итерации в цикле java
Еще одним видом управляющих конструкций являются циклы. Циклы позволяют в зависимости от определенных условий выполнять определенное действие множество раз. В языке Java есть следующие виды циклов:
Цикл for
Цикл for имеет следующее формальное определение:
for ([инициализация счетчика]; [условие]; [изменение счетчика]) < // действия >
Рассмотрим стандартный цикл for:
for (int i = 1; i
Первая часть объявления цикла — int i = 1 создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип int . Это может быть и любой другой числовой тип, например, float. Перед выполнением цикла значение счетчика будет равно 1. В данном случае это то же самое, что и объявление переменной.
Вторая часть — условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока i не достигнет 9.
И третья часть — приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i— .
В итоге блок цикла сработает 8 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.
Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:
int i = 1; for (; 😉
Определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (; 😉 . Теперь нет инициализированной переменной-счетчика, нет условия, поэтому цикл будет работать вечно — бесконечный цикл.
Либо можно опустить ряд блоков:
int i = 1; for (; i
Этот пример эквивалентен первому примеру: у нас также есть счетчик, только создан он вне цикла. У нас есть условие выполнения цикла. И есть приращение счетчика уже в самом блоке for.
Цикл for может определять сразу несколько переменных и управлять ими:
int n = 10; for(int i=0, j = n — 1; i
Цикл 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)
Операторы continue и break
Оператор break позволяет выйти из цикла в любой его момент, даже если цикл не закончил свою работу:
for (int i = 0; i
Когда счетчик станет равным 5, сработает оператор break, и цикл завершится.
Теперь сделаем так, чтобы если число равно 5, цикл не завершался, а просто переходил к следующей итерации. Для этого используем оператор continue :
for (int i = 0; i
В этом случае, когда выполнение цикла дойдет до числа 5, программа просто пропустит это число и перейдет к следующему.
- Вопросы для самопроверки
- Упражнения
Цикл for
Конструкция for управляет циклами. Команда выполняется до тех пор, пока управляющее логическое выражение не станет ложным.
Цикл for является наиболее распространённым циклом в программировании, поэтому его следует изучить. Цикл for проводит инициализацию перед первым шагом цикла. Затем выполняется проверка условия цикла, и в конце каждой итерации происходит изменение управляющей переменной. Выглядит следующим образом:
for(инициализация; логическое выражение (условие); шаг (итерация)) команда
Любое из трёх выражений цикла (инициализация, логическое выражение или шаг) можно пропустить. Перед выполнением каждого шага цикла проверяется условие цикла. Если условие окажется ложным, то выполнение продолжится с инструкции, следующей за конструкцией for.
Помните, что выражение инициализации выполняется один раз, затем вычисляется условие, которое должно быть булевым выражением.
Как правило, цикл for используют для перебора. В качестве имени первой переменной часто используют i (сокр. от init), но вы можете использовать любое имя.
for (int x = 0; x < 9; x = x + 1) mInfoTextView.append("\nЗначение x: " + x);
Третье выражение в цикле - шаг, то есть, на какое значение нужно изменить переменную. Строго говоря, в таком виде (x = x + 1) современные программисты не пишут, так как есть укороченная форма записи (x++). Предыдущий пример можно переписать по другому:
for (int x = 0; x < 9; x++)
Эта запись является классической и правильной, если нам нужно посчитать от 0 до 8. Может возникнуть соблазн написать, например, так:
for (int x = 0; x
Результат будет таким же, но такой код нежелателен. Старайтесь писать традиционно. Особенно это проявляется при работе с массивами.
Увеличение значения переменной на единицу - весьма распространённый случай. Но это не является обязательным условием цикла, вы можете установить шаг и с помощью умножения, вычитания и других действий. Например, мы хотим вывести процесс уменьшения жизней у очень любопытной кошки:
for (int life = 9; life >= 0; life--) mInfoTextView.append("\nУ кошки осталось жизней: " + life);
Попробуйте потренироваться на кошках . Например, выводим чётные числа.
for (int x = 0; x < 9; x += 2) mInfoTextView.append(" " + x); // между кавычками пробел
0 2 4 6 8
Если нужно выполнить несколько операторов в цикле, то используют фигурные скобки.
for (int kitten = 1; kitten
В этом примере выполняется цикл с выводом числа подсчитанных котят, а также выводится текст в текстовом поле. Кстати, это один из примеров неправильного кода, когда в текстовом поле девять раз подряд выводится одна и та же строка. Мы этого не замечаем, но в реальности процессор выполняет лишнюю работу и второй оператор безусловно нужно вынести за пределы блока кода, который относится к циклу. Подобные ошибки очень часто встречаются у начинающих программистов, которые забывают, как работает цикл.
Когда мы объявляем переменную в первой части оператора for(int i = 0; . ), то область видимости переменной ограничена телом цикла и эта переменная не доступна на другом участке кода. Это подходящий вариант, если переменная больше нигде не используется. При этом переменная имеет область видимости и продолжительность существования, совпадающие с видимостью и продолжительностью жизни самого цикла. Вне цикла переменная прекратит своё существование.
Если управляющую переменную цикла нужно использовать в других частях приложения, то её не следует объявлять внутри цикла.
int i; // эта переменная нам понадобится не только в цикле for(i = 0; i < 10; i++)< // что-то делаем >// можем использовать переменную где-то ещё x = i + 10;
С другой стороны, если видимость переменной ограничена в пределах цикла, то не будет никакого конфликта, если вы будете использовать одинаковые имена переменных в разных циклах for, так как они не будут друг другу мешать.
Использование нескольких переменных
Иногда требуется указать несколько переменных в инициализационной части цикла. Для начала посмотрим на стандартный пример:
int a, b; b = 4; for(a = 1; a
В данном цикле используются две переменные. Можно включить обе переменные в оператор for, чтобы не выполнять обработку второй переменной вручную:
int a, b; for(a = 1, b = 4; a
Как видно из кода, запятая служит разделителем для двух переменных. Теперь оба разделённых запятой оператора в итерационной части цикла выполняются при каждом выполнении цикла. Данный код считается более эффективным, хотя на практике встречается редко.
Части цикла могут быть пустыми.
Оставим пустым первое выражение.
int i = 0; for(; i < 10; i++)< // что-то делаем mInfoTextView.append("\n" + i); >
В следующем примере нет инициализационного и итерационного выражения:
int i; boolean kind = false; i = 0; for( ; !kind; )
А можно вообще все три части оператора оставить пустыми:
В этом случае создаётся бесконечный цикл, который никогда не завершится. Практического смысла данный код не имеет.
Работа с массивами
С обычными числами обычно не работают в цикле for. Гораздо чаще цикл используют при работе с массивами.
Основная разница между ними, что массив может состоять из неупорядоченных чисел, а число элементов может быть разным. К счастью, у массива есть специальное свойство length - длина массива. Первый пример можно переписать следующим образом.
int[] mice = < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 >; for (int i = 0; i < mice.length; i++) mInfoTextView.append(" " + mice[i]);
Мы создали массив из чисел от 0 до 9. Затем проходим в цикле, но на этот раз во втором операторе не используем число 9, а вычисляем длину массива. Такой гибкий подход позволят проделывать с массивами разные трюки - упорядочивать, сортировать, переворачивать и т.д.
Например, если мы хотим вывести числа в обратном порядке, меняем логику следующим образом. Теперь нам нужно начинать вывод не с 0, а с 9, т.е. int i = 9 или int i = mice.length - 1 (для универсальности). Шаг будет не увеличиваться, а уменьшаться, значит - i--. А условием станет достижение 0, т.е. i >= 0. Проверяем.
int[] mice = < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 >; for (int i = mice.length - 1; i >= 0; i--)
Аналог foreach
Во многих языках существует более компактная форма for для перебора элементов массивов - foreach. Конструкция foreach не требует ручного изменения переменной-шага для перебора - цикл автоматически выполняет эту работу.
В Java решили не добавлять новое ключевое слово, а просто сделали усовершенствованный вид цикла for, который имеет вид:
for(тип итер_пер : коллекция) блок_операторов
Для сравнения напишем цикл для вычисления суммы значений элементов массива традиционным способом:
int[] nums = < 1, 2, 3, 4, 5 >; int sum = 0; for(int i = 0; i < 5; i++) sum += nums[i];
Этот код можно переписать следующим образом:
int[] nums = < 1, 2, 3, 4, 5 >; int sum = 0; for(int i : nums) sum += i;
При прохождении цикла переменной i автоматически присваивается значение, равное значению следующего элемента массива nums. Таким образом, при первом прохождении переменная i содержит значение 1, при втором - 2 и т.д. Кроме того при таком способе исключается возможность ошибок выхода за пределы массива.
Для этого способа можно использовать массив или любой класс с интерфейсом Iterable.
Можно прервать выполнение цикла с помощью оператора break:
int[] nums = < 1, 2, 3, 4, 5 >; int sum = 0; for(int i : nums) < sum += i; if(i == 3) break; // останавливаем цикл, если значение равно 3 >
Учтите, что в цикле в стиле foreach итерационная переменная доступна только для чтения, так как она связана только с исходным массивом. Даже если вы измените её значение, то это не повлияет на работу с массивом.
Также можно использовать данный способ для многомерных массивов.
Поскольку каждый оператор for в стиле foreach перебирает элементы массива последовательно, начиная с первого и заканчивая последним, то данный способ удобен для многих операций. Например, для поиска значения в неупорядоченном массиве. Поиск прекращается после обнаружения нужного значения.
int[] nums = < 3, 1, 6, 4, 9, 5, 8, 2 >; int val = 5; boolean found = false; // ищем значение 5 в массиве for (int x : nums) < if (x == val) < found = true; break; >> if (found)
Так как у нас неупорядоченный список, то нам нужно последовательно пройтись по всем элементам. Если нам повезёт и нужное значение встретится при переборе, то выходим из цикла и идём спать .
Вложенные циклы
Также допустимо использование вложенных циклов, когда один цикл выполняется внутри другого:
int i, j; for (i = 0; i < 10; i++) < for (j = i; j < 10; j++) < mInfoTextView.append("*"); >mInfoTextView.append("\n"); >
В результате получим:
При вложенных циклах количество повторений перемножается. В предыдущем примере было 100 повторений. Например, можно написать таблицу умножения.
int i, j, a = 0; for (i = 1; i < 10; i++) < for (j = 1; j < 10; j++) < a = i * j; System.out.print(a + " | "); >System.out.println(); >
Результат смотрите в вкладке LogCat.
Цикл for является более удобным вариантом цикла while.
for(int i = 10; i > 0; i--)
Этот же вариант с while:
int i = 10; while(i > 0)
С помощью цикла можно рисовать красивые узоры, меняя координаты одной фигуры.
Треугольник Флойда
Составьте "Треугольник Флойда", который выглядит как набор чисел, которые увеличиваются на единицу. Например, треугольник с высотой шесть строк выглядит следующим образом.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
Циклы в языке программирования Java
Основы синтаксиса Java
Как стать программистом Java, если ты программист 1С?
Зачем Java разработчикам читать книги по Java
Почему стоит учить Java?
Циклы — одна из наиболее важных конструкций в языке программирования Java. Они позволяют нам выполнять повторяющиеся операции и управлять потоком выполнения программы. Циклы позволяют автоматизировать задачи, которые требуют многократного повторения одних и тех же действий.
В этой статье мы рассмотрим циклы java, их особенности и способы использования. Мы изучим циклы `for`, `while` и `do-while`, а также научимся применять операторы `break` и `continue` для более точного контроля выполнения циклов.
Понимание работы и использования циклов в Java является ключевым навыком для каждого программиста, и позволяет создавать эффективный и удобочитаемый код. В этой статье мы рассмотрим, как циклы могут упростить разработку программ.
Циклы в языке Java: что это такое и как применяется
Циклы в языке программирования Java представляют собой механизмы, которые позволяют повторять определенные операции или блоки кода несколько раз. Они предоставляют способ автоматизировать итеративные действия и контролировать поток выполнения программы.
Циклы используются в программировании для решения задач, требующих повторения одного или нескольких операций определенное количество раз или до выполнения определенного условия.
Готовы окунуться в мир программирования, но не знаете, с чего начать? FoxmindEd предлагает быстрый и качественный старт!
⭐️ Преимущества FoxmindEd Java Start:
- Краткий курс: Мы предоставляем только необходимые базовые знания.
- ⏰ Быстро и эффективно: Курс можно пройти всего за 1-2 недели.
- Готовность к курсу менторинга Java Spring
Также курсы доступны по направлениям Java, C#, Python и JavaScript, а также специализированные курсы Java Tools и Задания перед менторингом.
Для кого подходит курс Java Start?
- Для новичков, готовых начать свой путь в программировании.
- Для тех, кто хочет быстро освоить основы.
Цикл for в Java: обзор, примеры кода
Цикл `for` является одним из наиболее часто используемых циклов в языке программирования Java. Он предоставляет удобный способ для повторения операций, таких как обход элементов массива или выполнение определенного количества итераций. Синтаксис цикла `for` выглядит следующим образом:
```java for (инициализация; условие; итерация) < // код, выполняемый внутри цикла >```
- `инициализация` — это блок кода, который выполняется один раз перед началом цикла. В этом блоке обычно происходит инициализация переменных, которые будут использоваться в цикле.
- `условие` — это логическое выражение, которое проверяется перед каждой итерацией цикла. Если условие истинно, цикл продолжает выполняться, если условие ложно, цикл завершается.
- `итерация` — это блок кода, который выполняется после каждой итерации цикла. Обычно в этом блоке происходит изменение значений переменных для контроля поведения цикла.
Вот пример использования цикла `for` для вывода чисел от 1 до 5:
```java for (int i = 1; i ```
Цикл `for` предоставляет более компактный и выразительный способ для выполнения итераций и контроля повторяющихся операций в языке Java. Он широко применяется программистами для решения различных задач, связанных с обработкой данных и управлением потоком выполнения программы.
Цикл while в Java: обзор, примеры кода
Цикл `while` является одним из основных циклов в языке программирования Java, который позволяет выполнять повторяющиеся операции до тех пор, пока заданное условие остается истинным. Этот цикл имеет гибкий синтаксис, который позволяет легко адаптировать его под различные ситуации.
Синтаксис цикла `while` выглядит следующим образом:
```java while (условие) < // код, выполняемый внутри цикла >```
Здесь `условие` представляет собой логическое выражение, которое проверяется перед каждой итерацией цикла. Если условие остается истинным, код внутри цикла выполняется, а при ложном условии цикл завершается.
Вот пример использования цикла `while` для вывода чисел от 1 до 5:
```java int i = 1; while (i ```
Цикл `while` является полезным инструментом, особенно когда количество итераций заранее неизвестно или зависит от внешних условий. Он позволяет гибко контролировать выполнение операций и организовывать повторяющиеся действия в программе.
Использование цикла `while` требует внимательности, чтобы избежать возможности попадания в бесконечный цикл. Необходимо убедиться, что условие цикла будет ложным в определенный момент, чтобы избежать зацикливания программы.
В целом, цикл `while` является мощным инструментом программирования, который позволяет эффективно управлять повторяющимися операциями в Java и применяется в различных ситуациях для достижения нужной функциональности и логики программы.
Цикл do-while в Java: обзор, примеры кода
Цикл `do-while` в языке программирования Java предоставляет возможность выполнить операции хотя бы один раз, а затем продолжить выполнение в зависимости от заданного условия. Синтаксис цикла `do-while` выглядит следующим образом:
```java do < // код, выполняемый внутри цикла >while (условие); ```
- `код` — это блок операций, который будет выполнен хотя бы один раз.
- `условие` — это логическое выражение, проверяемое после каждой итерации цикла. Если условие истинно, цикл продолжает выполнение; если условие ложно, цикл завершается.
Вот пример использования цикла `do-while` для вывода чисел от 1 до 5:
```java int i = 1; do < System.out.println(i); i++; >while (i
Цикл `do-while` полезен, когда необходимо выполнить операции хотя бы один раз, даже если условие ложно с самого начала.
Понимание «вечного» цикла и его предотвращение
«Вечный» цикл, также известный как бесконечный цикл, — это цикл, который выполняется бесконечно без прерывания. Он может возникнуть, когда условие цикла всегда истинно или когда отсутствует код, который изменяет условие цикла для выхода из него.
Вот пример «вечного» цикла:
```java while (true) < // код, выполняемый внутри цикла >```
В этом примере условие `true` всегда истинно, поэтому цикл будет выполняться бесконечно. Бесконечные циклы нежелательны, поскольку они могут привести к зависанию программы или потреблению большого количества ресурсов.
Для предотвращения «вечного» цикла важно убедиться, что условие цикла в конечном итоге станет ложным или что в цикле есть код, который изменяет условие для выхода из цикла.
Вложенные циклы в Java: что это такое и как их использовать
Вложенные циклы в Java — это циклы, которые содержатся внутри других циклов. Они позволяют выполнить повторяющиеся операции внутри других повторяющихся операций. Вложенные циклы особенно полезны при работе с многомерными структурами данных, такими как двумерные массивы.
Пример вложенных циклов:
```java for (int i = 1; i > ```
В этом примере внешний цикл `for` выполняется три раза, а внутренний цикл `for` выполняется три раза для каждой итерации внешнего цикла. В результате будут выведены все комбинации значений `i` и `j` от 1 до 3.
Вложенные циклы могут быть использованы для обработки сложных структур данных, манипуляций с матрицами, поиска и т.д.
Примеры использования циклов для решения практических задач
Циклы позволяют программистам эффективно обрабатывать повторяющиеся задачи и контролировать поток выполнения программы. Они позволяют автоматизировать итеративные операции, обрабатывать большие объемы данных и решать разнообразные задачи, связанные с повторением и обработкой информации.
Похожие материалы
Основы синтаксиса Java
Как стать программистом Java, если ты программист 1С?
Зачем Java разработчикам читать книги по Java
Цикл for в Java: что это, как с ним работать
Конструкция, чтобы много раз выполнять один и тот же участок кода.
Анастасия Хамидулина
Автор статьи
25 апреля 2022 в 18:57
В обычной жизни мы часто сталкиваемся с периодическими явлениями. Например, дневным циклом — солнце каждый день всходит и заходит. Или годовым — зима, весна, лето, осень сменяют друг друга. В программировании, чтобы описать повторяющиеся действия, тоже используют циклы — синтаксические конструкции, которые позволяют не писать один и тот же код много раз.
Общее о циклах
Конструкцию цикла можно описать так:
Условие завершения цикла — пока условие истинно, цикл будет выполняться.
Тело цикла — действия, которые мы хотим выполнить.
Рассмотрим несколько вариантов простейшего описания циклов в Java.
А чтобы узнать все тонкости работы с Java, приходите на курс от Skypro «Java-разработчик». Вы не только разберетесь в циклах, протоколах и объектах, но и попрактикуетесь, защитите дипломный проект и сможете найти работу по новой профессии — эта гарантия прописана в договоре.
Цикл while:
while(i <50) < //цикл будет выполняться, пока значение переменной i меньше 50. i++; //увеличиваем значение переменной i на 1 System.out.println(i); >
Условие завершения цикла может идти до или после его тела. Если условие цикла стоит после тела, то такой цикл называется циклом с постусловием. Его отличие от цикла с условием до тела в том, что минимум одна его итерация всегда будет выполнена.
Цикл while с постусловием:
do < i++; System.out.println(i); >while(i<50);
Тело цикла может содержать один или несколько операторов. Операторами могут быть и другие циклы, в таком случае они называются вложенными.
Несколько вложенных циклов while:
while(i <50) < while(j<5) < j++; System.out.println(i+j); >i++; >
Цикл for
В примерах выше мы на каждой итерации увеличиваем значение переменной — индекса. И завершаем цикл, когда это значение достигает предела. В дополнение к полезным операциям в теле цикла приходится добавлять служебную операцию, чтобы контролировать поведение индекса. Еще при подобном алгоритме нужно отдельно описывать операцию инициализации индекса. Чтобы сделать описание подобных конструкций компактным и удобным, есть оператор цикла for.
Как работать с циклами, индексами, массивами и объектами, расскажут на курсе «Java-разработчик». Опытные преподаватели объяснят сложное простым языком, а наставники помогут выполнить практические задания. Эти проекты добавите в свое портфолио.
Синтаксис цикла for:
Пример цикла for:
for (int i=0;i <10;i++) < // Полезные команды >
Станьте Java-разработчиком в два раза быстрее
Ускоренный курс для тех, кто хочет быстрее перейти на удаленку
Справка: переменную индекса в цикле for часто именуют i по первой букве английского слова index.
Этот пример — каноническое описание цикла for. Такая конструкция удобна при выполнении действий, например, с элементами массива:
int[] array = … for (int i=0;i
Обратный цикл for
Индекс можно не только увеличивать, но и уменьшать. Такие циклы for называют обратными:
for (int i = array.length-1;i>=0;i--)
Цикл for с произвольным шагом
Необязательно изменять значение индекса именно на единицу. Шаг может быть любым:
for (int i=0;i
Вложенные циклы for
Два цикла for, где один цикл вложен в другой, позволяют легко работать с двумерными массивами — матрицами:
int[][] matrix = … for (int i=0;i>
Иллюстрация работы программы
Ограничений на глубину вложенности циклов в компиляторе Java нет. Но избегайте большого количества вложенных друг в друга циклов, так как иначе усложните код программы.
Бесконечные циклы for
Если условие завершения цикла будет всегда истинным, вы получите бесконечный цикл:
for(int i=0;true;i++)
В примере условие завершения всегда истинно — мы задали ему константное значение true. Поэтому цикл будет бесконечно увеличивать индексную переменную и печатать ее значение в консоли.
Выражения, задающие поведение оператора for, не относят к обязательным, их можно опустить. Оператор for будет таким:
С точки зрения компилятора такое описание — допустимо, ошибки при запуске программы не будет. В результате вы опять получите бесконечно выполняющийся цикл, в теле которого нет доступа к индексной переменной.
❗ Бесконечные циклы for — вырожденные варианты описания логики программы, поэтому применяйте их только в специальных случаях. В обычных же ситуациях следите, чтобы условие завершения обязательно выполнялось на определенной итерации цикла. Неожиданные появления бесконечных циклов в логике программы приводят к тому, что приложение зависает и работает нестабильно. А еще к бесконтрольному потреблению ресурсов компьютера.
Как использовать циклы правильно, узнаете на курсе Skypro «Java-разработчик». Понадобится всего три часа в день, чтобы освоить все тонкости работы младшего специалиста.
Операторы, изменяющие поведение цикла
Используйте оператор прерывания break, если хотите завершить цикл досрочно:
DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek(); for (int i = 0; i >
Во все дни, кроме понедельника, программа напечатает цифры от нуля до девяти, а в понедельник — от нуля до пяти. Это произойдет, потому что оператор break завершит цикл досрочно — до того, как условие завершения вернет false.
Работа программы в среду
Работа программы в понедельник
Другой оператор, который меняет линейное выполнение команд в теле цикла, — continue. Он не прерывает цикл в целом, но сообщает программе, что нужно немедленно перейти к следующей итерации цикла:
DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek(); for (int i = 0; i System.out.println(i); >
В примере программа тоже будет печатать цифры от нуля до девяти. Но если ее запустить в пятницу, то цифру пять она не напечатает: оператор continue укажет, что нужно начать новую итерацию цикла и пропустить операцию вывода на экран.
Работа программы во вторник
Работа программы в пятницу
Оператор foreach
Мы рассмотрели примеры цикла for, где полностью настраивали его поведение: задавали начальное значение индексной переменной, устанавливали шаг ее изменения, определяли условие завершения. Если же вы хотите перебрать элементы коллекции или массива и последовательно выполнить действия над каждым, начинайте с первого элемента (i=0).
Чтобы создавать подобные циклы было проще, в Java 1.6 добавили оператор foreach.
Синтаксис оператора foreach:
Коллекция — массив или объект-наследник класса Iterable, элементы которого нужно последовательно перебрать.
Пример оператора foreach:
String[] words = new String[] ; for (String word: words)
В примере программа последовательно переберет все элементы массива words и напечатает их.
В теле foreach можно применять операторы break и continue: результат будет такой же, как и для обычного for.