Что нужно соблюдать для использования For Each?

Что нужно соблюдать для использования For Each?

For-each цикл (enhanced for loop) — это удобный способ итерации по коллекциям в Java. Но есть важные условия для его работы.

Основное требование: Iterable интерфейс

For-each цикл работает ТОЛЬКО с объектами, реализующими интерфейс Iterable:

// ПРАВИЛЬНО: ArrayList реализует Iterable
List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
for (String name : names) {  // Работает!
    System.out.println(name);
}

// НЕПРАВИЛЬНО: Integer не реализует Iterable
int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {  // Работает для массивов!
    System.out.println(number);
}

// НЕПРАВИЛЬНО: обычный объект
public class Person {}

Person person = new Person();
for (String item : person) {  // Ошибка компиляции!
    // for (String item : person) error: Person does not implement Iterable
}

Условие 1: Реализовать Iterable<T>

// Правильный способ
public class PersonCollection implements Iterable<Person> {
    private List<Person> people = new ArrayList<>();
    
    @Override
    public Iterator<Person> iterator() {
        return people.iterator();
    }
    
    public void add(Person person) {
        people.add(person);
    }
}

// Теперь можно использовать for-each
PersonCollection collection = new PersonCollection();
collection.add(new Person("Alice"));
collection.add(new Person("Bob"));

for (Person person : collection) {  // Работает!
    System.out.println(person.getName());
}

Условие 2: Правильная реализация Iterator

Метод iterator() должен возвращать правильный Iterator:

public class CustomCollection<T> implements Iterable<T> {
    private T[] items;
    
    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            private int index = 0;
            
            @Override
            public boolean hasNext() {
                return index < items.length;
            }
            
            @Override
            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                return items[index++];
            }
            
            @Override
            public void remove() {  // Optional
                // Удалить текущий элемент
            }
        };
    }
}

Условие 3: Правильная типизация

// ПРАВИЛЬНО: тип параметра совпадает с типом элементов
List<String> strings = new ArrayList<>();
for (String str : strings) {  // Правильный тип
    System.out.println(str);
}

// НЕПРАВИЛЬНО: несоответствие типов
List<Integer> numbers = new ArrayList<>();
for (String item : numbers) {  // Ошибка типизации!
    // type error: String cannot be converted to Integer
}

// ПРАВИЛЬНО: использовать Object для unknown types
List<?> unknown = new ArrayList<>();
for (Object item : unknown) {
    System.out.println(item);
}

Условие 4: Массивы (работают напрямую)

// Примитивные типы
int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {  // Работает
    System.out.println(number);
}

// Объекты
String[] names = {"Alice", "Bob", "Charlie"};
for (String name : names) {  // Работает
    System.out.println(name);
}

// Многомерные массивы
int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
for (int[] row : matrix) {  // Работает
    for (int value : row) {
        System.out.println(value);
    }
}

Условие 5: null не разрешён

// НЕПРАВИЛЬНО: null вызывает NullPointerException
List<String> list = null;
for (String item : list) {  // NullPointerException!
    System.out.println(item);
}

// ПРАВИЛЬНО: проверка на null
List<String> list = getList();
if (list != null) {
    for (String item : list) {
        System.out.println(item);
    }
}

// Или использовать Optional
Optional.ofNullable(getList())
    .ifPresent(list -> {
        for (String item : list) {
            System.out.println(item);
        }
    });

Проблема 1: Modification while iterating

// ОПАСНО: ConcurrentModificationException
List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
for (String name : names) {
    if (name.equals("Bob")) {
        names.remove(name);  // ConcurrentModificationException!
    }
}

// ПРАВИЛЬНО 1: использовать Iterator
List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
Iterator<String> it = names.iterator();
while (it.hasNext()) {
    String name = it.next();
    if (name.equals("Bob")) {
        it.remove();  // Безопасно удалить
    }
}

// ПРАВИЛЬНО 2: создать копию
List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
for (String name : new ArrayList<>(names)) {  // Итерируем по копии
    if (name.equals("Bob")) {
        names.remove(name);  // Удаляем из оригинала
    }
}

// ПРАВИЛЬНО 3: removeIf
List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
names.removeIf(name -> name.equals("Bob"));  // Clean и безопасно

Проблема 2: For-each vs Iterator

// For-each
for (String item : list) {
    // Это эквивалентно:
}

// Что происходит под капотом:
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
    String item = iterator.next();
}

// Donc, for-each создаёт Iterator автоматически

Проблема 3: Производительность

// Медленно: LinkedList требует O(n) для доступа по индексу
LinkedList<Integer> list = new LinkedList<>(Arrays.asList(1,2,3,4,5));
for (Integer item : list) {  // O(n) для каждого элемента → O(n²)
    System.out.println(item);
}

// Быстро: ArrayList требует O(1)
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
for (Integer item : list) {  // O(1) для каждого элемента → O(n)
    System.out.println(item);
}

// Или используй Iterator явно для LinkedList
LinkedList<Integer> list = new LinkedList<>(...);
for (Iterator<Integer> it = list.iterator(); it.hasNext(); ) {
    Integer item = it.next();  // O(1) с Iterator
}

Проблема 4: Переменная цикла — копия

// ЗНАЙ ЧТО ПРОИСХОДИТ
List<StringBuilder> builders = new ArrayList<>();
builders.add(new StringBuilder("Hello"));
builders.add(new StringBuilder("World"));

for (StringBuilder sb : builders) {
    sb.append(" modified");  // Изменяет объект в списке (ссылка!)
}

// Для примитивных типов: копия значения
int[] numbers = {1, 2, 3};
for (int number : numbers) {
    number = 10;  // Изменяет локальную копию, не массив
}
assert numbers[0] == 1;  // Оригинал не изменился

Проблема 5: Generics и type erasure

// ВАЖНО: type erasure удаляет информацию о типе
List<String> strings = new ArrayList<>();
for (String str : strings) {
    System.out.println(str);  // Работает, но информация о типе удалена в runtime
}

// Нельзя создать массив с generic типом
List<String>[] lists = new List<String>[10];  // Ошибка компиляции!

Рекомендуемые практики

// 1. Всегда проверяй null
List<String> list = getList();
if (list != null) {
    for (String item : list) {
        // ...
    }
}

// 2. Для LinkedList используй Iterator
LinkedList<String> list = new LinkedList<>();
for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
    String item = it.next();
    if (shouldRemove(item)) {
        it.remove();
    }
}

// 3. Используй removeIf для удаления
list.removeIf(item -> shouldRemove(item));

// 4. Stream API как альтернатива
list.stream()
    .filter(item -> !shouldRemove(item))
    .forEach(System.out::println);

// 5. Используй var для упрощения кода (Java 10+)
for (var item : list) {  // Тип выводится автоматически
    System.out.println(item);
}

Итоговый чеклист

• ✅ Объект реализует Iterable<T>
• ✅ Метод iterator() возвращает правильный Iterator
• ✅ Тип переменной цикла совпадает с типом элементов
• ✅ Коллекция не null
• ✅ Не модифицируешь коллекцию во время итерации (или используешь Iterator.remove())
• ✅ Для LinkedList используешь Iterator, не for-each
• ✅ Знаешь, что это синтаксический сахар над Iterator