Цикл For в Java

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

System.out.println(0);
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
// И так далее

Этот код займет 100 строк! Очень много. А вот как это будет выглядеть с циклом:

for(int i = 0; i < 100; i++) {
   System.out.println(i);
}

Всего 3 строки! Если нужен короткий ответ: for это цикл со счетчиком. В круглых скобках через точку с запятой пишут три части: с чего начать, до каких пор продолжать и как менять счетчик на каждом шаге. Запись for (int i = 0; i < 5; i++) читается как «начни с нуля, повторяй, пока i меньше пяти, и после каждого прохода прибавляй единицу».

Кратко

• for повторяет блок кода заданное число раз. Заголовок состоит из трех частей через точку с запятой: инициализация, условие продолжения и оператор счетчика.
• Порядок такой: инициализация один раз, затем проверка условия, затем тело, затем счетчик, и снова проверка. Поэтому for (int i = 0; i < 5; i++) печатает сначала 0, а не 1.
• Как только условие становится ложным, цикл заканчивается. Если поставить в условие константу true, код после цикла не скомпилируется: unreachable statement.
• Переменных в заголовке может быть несколько: for (int i = 5, j = 11; i != j; i++, j--).
• Чтобы просто перебрать массив или коллекцию целиком, удобнее расширенный for: for (String s : stringArray), счетчик и условие писать не нужно.
• break досрочно выходит из цикла, а запись for (;;) без всех трех частей дает бесконечный цикл.

Что такое циклы for?

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

1. Приготовить стакан.
2. Открыть крышку.
3. Получить 1-ю каплю.
4. Получить 2-ю каплю.
5. …
32. Получить 30-ю каплю.
33. Закрыть лекарство.
34. Принять полученную порцию.

Этот алгоритм можно объяснить гораздо быстрее:

1. Приготовить стакан.
2. Открыть крышку капель.
3. Получить 30 капель.
4. Закрыть лекарство.
5. Принять полученную порцию.

Мы практически каждый день используем цикл for в разговоре с другими людьми: “...20 шагов дальше по улице...”, “...сделай 10 повторений и еще 5 в 2 раза медленнее…”, “...сделай 5 покупок в различных категориях и получи приз…” можно продолжать долго, но смысл ясен. В Java Цикл for необходим для сокращения кода и его лаконичности.

Принцип работы цикла for

For цикл используется следующим образом:

for(<начальная точка>; <условие выхода>; <операторы счетчика>) {
	// Тело цикла
}

Пример перебора цифр от 0 до 5 и вывод каждой в консоль:

for(int i = 0; i < 5; i++) {
   System.out.println(i);
}

Вывод:

0
1
2
3
4

Если перевести данную запись на человеческий язык, получится следующее: “Создай переменную i с начальным значением 0, пока она не достигнет 5, прибавляй к ней по 1 и на каждом шаге записывай значение i в консоль.” В основе работы цикла for в Java лежат три стадии, их можно изобразить следующей схемой: Условие выхода из цикла это булево выражение. Если оно ложно, цикл будет завершен. В примере выше переменная i увеличивается на 1. Если ее значение менее 5, цикл продолжается. Но как только i станет больше или равно 5, цикл прекратится. Оператор счетчика это выражение, которое выполняет преобразование переменной счетчика. В примере выше переменная i увеличивалась на 1. То есть цикл будет выполнен ровно 5 раз. Если оператор счетчика будет прибавлять по 2 к переменной i, результат будет иным:

for(int i = 0; i < 5; i = i + 2) {
   System.out.println(i);
}

Вывод:

0
2
4

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

for(int i = 0; true; i++) {
   if(i % 1000000 == 0) System.out.println(i);
}
System.out.println("Loop ended");

То код после цикла будет помечен ошибкой unreachable statement, так как никогда не будет исполнен. Задача на смекалку: в результате запуска кода ниже будет ли выведено в консоль “Loop ended” или цикл будет выполняться бесконечно?

for(int i = 0; i > -1; i++) {
   if(i % 1000000 == 0) System.out.println(i);
}
System.out.println("Loop ended");

Ответ: будет. Переменная i рано или поздно достигнет максимального значения int, то есть 2147483647, а следующее увеличение переполнит ее и превратит в минимальное значение int, то есть -2147483648. Условие i > -1 станет ложным, и цикл завершится.

Цикл forEach

При работе с циклами иногда приходится перебирать массивы или коллекции. Обычно массив можно перебрать с помощью цикла for:

public void printAllElements(String[] stringArray) {
   for(int i = 0; i < stringArray.length; i++) {
       System.out.println(stringArray[i]);
   }
}

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

for(<Тип элемента> <Имя переменной, куда будет записан очередной элемент> : <Название массива>) {
	// Тело цикла
}

Перебрать массив строк и вывести каждую в консоль можно следующим способом:

public void printAllElements(String[] stringArray) {
   for(String s : stringArray) {
       System.out.println(s);
   }
}

Тоже кратко и лаконично. Самое главное, нет нужды думать о счетчике и об условии выхода, все уже сделано за нас.

Как используются циклы for

А теперь рассмотрим несколько примеров использование цикла for в Java для решения разнообразных задач.

Обратный цикл (от большего к меньшему)

Счетчик можно не только увеличивать, но и уменьшать:

for(int i = 5; i > 0; i--) {
   System.out.println(i);
}

Вывод:

5
4
3
2
1

Несколько переменных и увеличение счетчика в теле цикла

В цикле for можно использовать несколько переменных, например их можно преобразовывать в операторе счетчика:

int a = 0;
for(int i = 5; i > 0; i--, a++) {
   System.out.print("Шаг: " + a + " Значение: ");
   System.out.println(i);
}

Вывод:

Шаг: 0 Значение: 5
Шаг: 1 Значение: 4
Шаг: 2 Значение: 3
Шаг: 3 Значение: 2
Шаг: 4 Значение: 1

Или объявить две переменные и идти по циклу, пока они не будут равны друг другу:

for(int i = 5, j = 11; i != j; i++, j--) {
   System.out.println("i: " + i + " j: " + j);
}

Вывод:

i: 5 j: 11
i: 6 j: 10
i: 7 j: 9

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

for(int i = 0; i < 5; i++) {
   System.out.print(i + " | ");
   for(int j = 0; j < 5; j++) {
       System.out.print(j + " ");
   }
   System.out.print('\n');
}

Вывод:

0 | 0 1 2 3 4 
1 | 0 1 2 3 4 
2 | 0 1 2 3 4 
3 | 0 1 2 3 4 
4 | 0 1 2 3 4

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

int[][] array = { {0, 1, 2, 3, 4 },
                       {1, 2, 3, 4, 5},
                       {2, 3, 4, 5, 6},
                       {3, 4, 5, 6, 7}};

for(int i = 0; i < array.length; i++) {
   for(int j = 0; j < array[i].length; j++) {
       System.out.print(array[i][j] + " ");
   }
   System.out.print('\n');
}

Вывод:

0 1 2 3 4 
1 2 3 4 5 
2 3 4 5 6 
3 4 5 6 7 

Досрочное завершение цикла

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

public void getFirstPosition(String[] stringArray, String element) {
   for (int i = 0; i < stringArray.length; i++) {
       if(stringArray[i].equals(element)) {
           System.out.println(i);
           break;
       }
   }
}

Метод выведет позицию первого искомого элемента в массиве:

String[] array = {"one", "two", "three", "Jeronimo"};
getFirstPosition(array, "two");

Вывод:

1

Бесконечный цикл

Еще один способ создать бесконечный цикл for: оставить пустой область объявления счетчика, условие выхода и оператор счетчика:

for (;;) {
}

Но учти, что в большинстве случаев бесконечный цикл это свидетельство логической ошибки. У такого цикла обязательно должно быть условие выхода.

Вопросы и ответы

Как работает цикл for в Java?

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

Почему for (int i = 0; i < 5; i++) печатает сначала 0, а не 1?

Потому что счетчик увеличивается после тела цикла, а не до него. На первом проходе i еще равно начальному значению 0, оно и печатается. Последним выведется 4: когда i станет равно 5, условие i < 5 окажется ложным и цикл закончится.

Чем расширенный for (for-each) отличается от обычного?

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

Как выйти из цикла досрочно?

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

Видна ли переменная счетчика после цикла?

Нет, если она объявлена прямо в заголовке: for (int i = 0; ...) ограничивает жизнь i самим циклом. Если переменная нужна и после, ее объявляют до цикла, а в заголовке оставляют только присваивание.

Как сделать бесконечный цикл for?

Оставить все три части пустыми: for (;;) {}. Тот же эффект даст константное условие true. Выходить из такого цикла нужно через break внутри тела, иначе программа зависнет. Причем с константой true код после цикла вообще не скомпилируется. Источник: Oracle Java Tutorials: The for Statement.

Читайте также

• Циклы в Java
• Цикл for-each в Java
• Операторы break, continue и return в Java
• Цикл while в Java