Цикл for-each в Java: синтаксис, примеры и подводные камни

Когда индекс только мешает

Цикл for со счётчиком даёт вам счётчик, условие и шаг обновления. Но в огромном числе случаев позиция элемента вас на самом деле не интересует — вы просто хотите что-то сделать с каждым, по порядку, от начала до конца. Управлять индексом ради этого — лишняя работа, и именно здесь подкрадываются ошибки на единицу (off-by-one).

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

Базовый синтаксис

Форма такова: for (Тип элемент : коллекция). Читайте двоеточие как слово «в»:

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 100};

        for (int score : scores) {
            System.out.println("Score: " + score);
        }
    }
}

Нет i, нет scores.length, нет scores[i]. На каждом проходе score и есть следующий элемент. Цикл выполняется один раз на каждый элемент и автоматически останавливается, когда их больше нет — вы не сможете заехать за конец или начать на один элемент раньше.

Перебор списка

Тот же цикл работает с чем угодно перебираемым, включая List, Set и остальные типы коллекций. Тип элемента ставится перед именем переменной:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang + " has " + lang.length() + " letters");
        }
    }
}

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

var избавляет от написания имени типа

Если тип элемента длинный или очевидный, var позволяет компилятору вывести его, чтобы вы не повторялись:

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bo", 25);

        for (var entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Без var переменная цикла была бы громоздким Map.Entry<String, Integer>. var сохраняет читаемость, а тип по-прежнему полностью проверяется на этапе компиляции — это не вольный, динамический тип.

Ловушка с изменением

Вот правило, на котором спотыкаются все: нельзя добавлять элементы в коллекцию или удалять их из неё, пока цикл for-each её обходит. Это бросает ConcurrentModificationException:

List<String> items = new ArrayList<>(List.of("a", "b", "c"));

for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);   // бросает ConcurrentModificationException
    }
}

Цикл замечает, что список изменился под ним, и прекращает работу, вместо того чтобы молча пропускать или повторять элементы. Чтобы удалять безопасно, спуститесь к явному Iterator, у которого есть remove(), о котором цикл знает:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("a", "b", "c"));

        Iterator<String> it = items.iterator();
        while (it.hasNext()) {
            if (it.next().equals("b")) {
                it.remove();   // безопасно
            }
        }

        System.out.println(items);   // [a, c]
    }
}

Распространённое сокращение — items.removeIf(item -> item.equals("b")), которое делает то же самое в одну строку.

Только чтение, без переприсваивания

Ещё одно тонкое ограничение: присваивание переменной цикла меняет только локальную копию, а не коллекцию. Это удивляет тех, кто пришёл из языков, где переменная цикла — живая ссылка:

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};

        for (int n : nums) {
            n = n * 10;   // меняет копию, а не массив
        }

        System.out.println(nums[0]);   // всё ещё 1
    }
}

Если нужно записать обратно в массив, вам нужен индекс — а это означает классический цикл for со счётчиком: for (int i = 0; i < nums.length; i++) nums[i] = nums[i] * 10;. Для элементов-объектов вы можете изменить объект, на который указывает переменная (например, вызвав сеттер), но не можете заменить его в коллекции.

break и continue по-прежнему работают

for-each — это настоящий цикл, поэтому break и continue ведут себя точно так же, как везде: break выходит из цикла, continue переходит к следующему элементу:

public class Main {
    public static void main(String[] args) {
        String[] words = {"keep", "skip", "keep", "stop", "never"};

        for (String w : words) {
            if (w.equals("skip")) continue;   // пропустить этот
            if (w.equals("stop")) break;      // выйти совсем
            System.out.println(w);
        }
    }
}

Это выводит keep, затем keep — пропускает "skip" и останавливается на "stop", не дойдя до "never". Так что вы не обязаны посещать каждый элемент; вы просто отказываетесь от индекса в обмен на более чистый код.

Далее: Массивы

Вы уже несколько раз проходили по массивам, не задерживаясь на том, что они такое на самом деле, — контейнеры фиксированного размера с индексами и тем самым полем .length. Следующая страница возвращается к началу и разбирает массивы как следует: как их объявлять, с какими значениями по умолчанию они стартуют и чем их фиксированный размер отличается от растущего ArrayList.