Циклы

**Циклы** — это специальные управляющие конструкции, которые предназначены для выполнения одних и тех же участков кода несколько раз.

## Цикл while

`while` (пока) `—` самый простой вариант цикла. Он выполняет код внутри себя, пока условие истинно (верно).

### Синтаксис

```
while (условие) {
 код
}

```
Код внутри цикла называется *телом цикла*, а каждое его выполнение — *итерацией цикла*.

### Примеры

```
int i = 1; //Переменная-счётчик
/\*
Цикл будет выполняться, пока переменная i не станет равной 10.

С каждой итерацией будет выводиться следующее число.
Напр., в начале i = 1, значит будет выведено 1.
Затем к i прибавится 1, и напечатается уже 2. И т.д. до 10
\*/

while (i != 10) {
 System.out.println(Integer.valueOf(i));
 i++;
}

```
По аналогии с `if`, фигурные скобки можно опустить, если тело состоит из одной строки кода.

## Цикл do-while

Можно к циклу `while` добавить блок `do`. В таком случае, когда выполнение дойдёт до блока `do`, он выполнится один раз, затем проверится условие, и блок `do` будет выполняться, пока это условие истинно.

### Синтаксис

```
do {
 тело цикла
} while (условие)

```

### Примеры

Пример также со счётом до 10.

```
int i = 1; //Переменная-счётчик

do {
 System.out.println(Integer.valueOf(i));
 i++;
}
while (i != 10)

```

### Синтаксис

```
for (инициализация\_счётчика; условие; изменение\_счётчика) {
 тело цикла
}

```
Это может показаться чем-то сложным, но на самом деле всё просто:

* Когда код доходит до `for`, он сначала задаёт значение указанной переменной-счётчику. Оно задаётся только **один** раз, перед выполнением итераций!
* Далее, проверяется условие. Если оно истинно, выполняется код в теле цикла.
* После очередной итерации, независимо от истинности условия, счётчик изменяется. Далее снова проверяется условие и так по кругу.

### Примеры

Опять пример со счётом.

```
for (int i = 1; i != 10; i++) {
 System.out.println(String.valueOf(i));
}

//Читается этот код так: создать переменную i = 1, пока i не равна 10,
//выполнять код и после каждой итерации инкрементировать i.

```
Этот тип циклов очень удобен при создании счётчиков и итерировании массивов, коллекций и т.д.

## Итерирование массива

**Итерировать массив** — это значит "пробежаться" по нему, делая какие-либо операции с каждым его элементом по очереди. Например, у нас есть массив целых чисел. И нам нужно ко всем 0 прибавить единицу. Сделать это можно так:

```
int[] numbers = {1,0,6,3,5,0,0,2,5,0,6};

for (int i = 0; i != numbers.length-1; i++) {

 if (numbers[i] == 0) {
 numbers[i]++;
 }

}

```
Разберём, как рабоатет этот код.

1. **Начало выполнения.** Переменной i присваивается значение 0, проверяется условие. Оно истинно, поэтому начинается первая итерация цикла.
2. **Первая итерация.** На этой итерации i = 0. В if проверяется условие: если элемент массива numbers под индексом i - это число 0, то надо этот элемент массива инкрементирвать. У нас нулевой элемент = 1, поэтому if пропускается, итерация завершается.
3. **Вторая итерация.** Перед началом итерации переменная-счётчик i увеличивается на 1. Теперь i = 1. А это значит, что if будет сравнивать с нулём элемент массива с индексом 1. Какое у нас там число, в этом индексе? Правильно, 0! Поэтому if добавляет к нему единицу.
4. **Последующие итерации**. Выполняются аналогично, до тех пор, пока не будет проитерирован весь массив. Тогда условие цикла `i != numbers.length-1` станет неверным, и цикл завершит работу.

## Цикл foreach

Формально это всё тот же `for`, но с немного другим синтаксисом.

**ПРИМЕЧАНИЕ.** Новички, вам сейчас не надо читать про foreach, вас сюда направят позже!

Статья не дописана........

## Операторы break и continue

`break` – это оператор выхода из цикла или switch. Если там встечается данный оператор, производится выход из конструкции и управление передаётся коду, следующему за ней.

### Пример

Этот код досчитал бы до 10, если бы не `break`. Когда i принимает значение 6, вместо вывода этого числа на экран и продолжения выполнения цикла, он завершается, и на экран выводится "Цикл завершился"

```
for (int i = 0; i != 10; i++) {
 if (i == 6) {
 break;
 }
 System.out.println(String.valueOf(i));
}

System.out.println("Цикл завершился");

```

### break как оператор перехода по метке

Ранее в Java был оператор для перехода по метке – `goto`. Однако сейчас Java не содержит оператора `goto`, потому что он выполняет переход произвольным и неструктурированным способом, а также отменяет некоторые оптимизации компилятора. Хотя самого оператора нет, его название всё равно осталось зарезервированным (им нельзя назвать методы, переменные и т.д.)

На смену `goto` пришёл `break`.

#### Пример

```
int counter = 1;
main: { //Ставим метку - чтобы это сделать,
 //пишем название метки и ставим двоеточие, не забывая про { }
System.out.println(String.valueOf(counter));
counter++;

}
if (counter != 10) {
 break main; //На метку main!
}

```