Цикл while в Java: синтаксис, do-while и частые ошибки

Когда у вас нет счётчика

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

Цикл while проверяет условие перед каждым проходом, включая самый первый. Если условие ложно с самого начала, тело не выполняется вовсе.

public class Main {
    public static void main(String[] args) {
        int count = 3;

        while (count > 0) {
            System.out.println("Liftoff in " + count);
            count--;
        }

        System.out.println("Go!");
    }
}

Условие count > 0 проверяется первым; если оно истинно, выполняется тело; затем мы возвращаемся в начало и проверяем снова. Строка count-- — это то, что в итоге делает условие ложным; уберите её, и цикл будет выполняться вечно.

Анатомия цикла while

Сравните его с трёхчастным циклом for, который вы уже знаете. Цикл while разносит эти три задачи: инициализацию вы делаете до цикла, условие идёт в скобках, а обновление живёт внутри тела.

int i = 0;              // инициализация - до цикла
while (i < 5) {         // условие - проверяется на каждом проходе
    System.out.println(i);
    i++;                // обновление - о нём нужно помнить самому
}

Эта последняя часть и есть подвох. В цикле for обновление стоит прямо рядом с условием, поэтому его трудно забыть. В цикле while это просто ещё один оператор в теле — самая частая ошибка как раз в том, чтобы пропустить его и подвесить программу.

do-while: выполнить тело хотя бы один раз

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

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int number;

        do {
            System.out.print("Enter a positive number: ");
            number = in.nextInt();
        } while (number <= 0);

        System.out.println("Thanks! You entered " + number);
    }
}

Нужно запросить и прочитать ввод хотя бы один раз, прежде чем вы сможете понять, корректен ли он, — именно это и даёт do-while. Обратите внимание на точку с запятой после while (...) — она обязательна, и её отсутствие — частая ошибка компиляции.

Отличие от обычного while ясно видно, когда условие изначально ложно:

public class Main {
    public static void main(String[] args) {
        int x = 10;

        // while: условие ложно сразу -> тело не выполняется никогда
        while (x < 5) {
            System.out.println("while body");
        }

        // do-while: выполняется один раз, ЗАТЕМ проверяет -> тело выполняется ровно один раз
        do {
            System.out.println("do-while body");
        } while (x < 5);
    }
}

Печатается только do-while body. Цикл while полностью пропускает своё тело, потому что x < 5 было ложным до первой проверки.

Цикл до сторожевого значения

Классическое применение while — читать до специального «стоп»-значения, сторожевого (sentinel). Здесь нет счётчика; вы просто продолжаете, пока данные не скажут вам остановиться:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = 0;

        System.out.println("Enter numbers to add (0 to finish):");
        int value = in.nextInt();

        while (value != 0) {
            sum += value;
            value = in.nextInt();
        }

        System.out.println("Total: " + sum);
    }
}

Шаблон такой: прочитать один раз до цикла, затем читать снова в конце каждого прохода. Так условие всегда проверяет свежий ввод. Если вы забудете второе чтение внутри тела, value никогда не изменится — и вы получите бесконечный цикл.

break и continue в циклах while

break и continue работают здесь так же, как в цикле for. break немедленно покидает цикл; continue сразу переходит к проверке условия, пропуская остаток текущего прохода:

public class Main {
    public static void main(String[] args) {
        int n = 0;

        while (true) {              // намеренный "бесконечный цикл"
            n++;
            if (n % 2 == 0) continue;   // пропускаем чётные числа
            if (n > 9) break;           // останавливаемся, перейдя за 9
            System.out.println(n);
        }
    }
}

Это печатает 1 3 5 7 9. while (true) намеренно никогда не останавливается сам по себе — единственный выход — break. Будьте осторожны с continue в цикле while: поскольку обновление является частью тела, переход в начало через continue до того, как вы продвинули счётчик, — это тихий способ подвесить цикл. В примере выше n++ выполняется первым, поэтому всё безопасно.

Остерегайтесь бесконечных циклов

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

int i = 0;
while (i < 5) {
    System.out.println(i);   // i никогда не меняется -> выполняется вечно
}

int i = 0;
while (i != 10) {
    i += 3;   // 0, 3, 6, 9, 12... проскакивает мимо 10 -> выполняется вечно
}

Первый зависает, потому что i никогда не обновляется. Второй зависает, потому что счётчик перешагивает через точное значение, которое ищет условие; предпочитайте < или <= вместо !=, когда шаг может не попасть точно. while (true) допустим, если у него есть гарантированный break; случайный — это просто баг.

Далее: цикл for-each

Цикл while — правильный инструмент, когда вы повторяете до изменения условия и нет понятного счёта. Но когда вы просто хотите пройти по каждому элементу массива или списка — без индекса, без условия для управления — есть кое-что ещё чище: усовершенствованный цикл for-each. Это следующая страница.