Глава 6. Итераторы

Интерфейс ListIterator — двунаправленный обход и расширенные возможности

ListIterator представляет собой специализированную версию интерфейса Iterator, разработанную исключительно для работы с реализациями интерфейса List. Этот расширенный интерфейс добавляет двунаправленный обход, модификацию элементов во время итерации и получение информации о текущей позиции. В отличие от базового Iterator, который предоставляет только однонаправленный обход и ограниченные возможности модификации, ListIterator превращает итерацию в полноценный механизм навигации по спискам.

ListIterator воплощает идею о том, что обход списка — это не просто последовательное чтение элементов, а полноценная навигация по структуре данных с возможностью движения в обоих направлениях, модификации элементов в любой точке и получения контекстной информации о текущей позиции. Этот подход особенно ценен для алгоритмов, требующих анализа соседних элементов или выполнения локальных модификаций без полного перебора коллекции.


Архитектура интерфейса ListIterator

ListIterator наследует от Iterator и добавляет значительное количество новых методов:

public interface ListIterator<E> extends Iterator<E> {
    // Наследуемые методы
    boolean hasNext();
    E next();
    void remove();
    
    // Новые методы
    boolean hasPrevious();
    E previous();
    int nextIndex();
    int previousIndex();
    void set(E e);
    void add(E e);
}

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


Фундаментальные методы двунаправленного обхода

hasPrevious() и previous(): Обратное движение

Концептуальное назначение

Методы hasPrevious() и previous() представляют собой зеркальное отражение hasNext() и next(), позволяющее двигаться по списку в обратном направлении. Эта пара методов реализует концепцию двунаправленного обхода, что является ключевым отличием ListIterator от базового Iterator.

Семантика и поведение

hasPrevious():
Возвращает true, если при движении в обратном направлении существуют элементы
Не изменяет состояние итератора
Может возвращать false в начальной позиции или после reset итератора

previous():
Возвращает предыдущий элемент и перемещает курсор назад
Выбрасывает NoSuchElementException, если предыдущих элементов нет
Устанавливает состояние для последующего вызова remove() или set()

Внутренние механизмы реализации

Позиционирование курсора

Ключевая концепция ListIterator — курсор, который находится между элементами списка.

Для списка из n элементов существует n+1 возможных позиций курсора:

Позиции курсора: 0   1   2   3   4
Элементы списка: [A] [B] [C] [D]

Семантика операций:
next() возвращает элемент после курсора и перемещает курсор вперед
previous() возвращает элемент перед курсором и перемещает курсор назад
remove() удаляет последний возвращенный элемент
set(E e) заменяет последний возвращенный элемент


Реализация для ArrayList

// Концептуальная реализация для ArrayList
public boolean hasPrevious() {
    return cursor > 0;
}

public E previous() {
    checkForComodification();
    int i = cursor - 1;
    if (i < 0) {
        throw new NoSuchElementException();
    }
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length) {
        throw new ConcurrentModificationException();
    }
    cursor = i;
    return (E) elementData[lastReturned = i];
}

Особенности:
Использование индекса вместо ссылок на узлы
Проверка границ массива
Обновление lastReturned для поддержки remove() и set()

Реализация для LinkedList

// Концептуальная реализация для LinkedList
public boolean hasPrevious() {
    return nextIndex > 0;
}

public E previous() {
    checkForComodification();
    if (!hasPrevious()) {
        throw new NoSuchElementException();
    }
    lastReturned = next = (next == null) ? last : next.prev;
    nextIndex--;
    return lastReturned.item;
}

Особенности:
Навигация по ссылкам prev
Обработка граничных условий (первый/последний элемент)
Корректировка next и nextIndex

#Java #для_новичков #beginner #ListIterator

Особенности производительности

Временная сложность:
ArrayList: O(1) для обеих операций
LinkedList: O(1) для перехода между соседними узлами
Память: Не создает дополнительных объектов при нормальной работе.
Потокобезопасность: Как и другие методы итератора, не является потокобезопасным.


Паттерны использования

Полный двунаправленный обход

ListIterator<String> iterator = list.listIterator();

// Движение вперед
while (iterator.hasNext()) {
    String element = iterator.next();
    processForward(element);
}

// Движение назад
while (iterator.hasPrevious()) {
    String element = iterator.previous();
    processBackward(element);
}

Поиск с возвратом

public static <T> int findAndReturn(List<T> list, T target) {
    ListIterator<T> iterator = list.listIterator();
    
    // Поиск вперед
    while (iterator.hasNext()) {
        if (iterator.next().equals(target)) {
            // Найдено - возвращаемся на две позиции назад
            iterator.previous(); // Возвращаемся к найденному элементу
            return iterator.previousIndex() + 1;
        }
    }
    
    return -1; // Не найдено
}

Сравнение соседних элементов

public static void processAdjacentPairs(List<Integer> numbers) {
    if (numbers.size() < 2) return;
    
    ListIterator<Integer> iterator = numbers.listIterator(1); // Начинаем со второго элемента
    
    while (iterator.hasNext()) {
        Integer current = iterator.next();
        Integer previous = iterator.previous(); // Переходим к предыдущему
        
        processPair(previous, current);
        
        iterator.next(); // Возвращаемся к текущему для продолжения
    }
}

nextIndex() и previousIndex(): Информация о позиции

Концептуальное назначение

Эти методы предоставляют информацию о текущей позиции итератора в списке, что позволяет реализовывать алгоритмы, зависящие от позиции элементов, без необходимости ведения внешних счетчиков или вычислений.

Семантика и поведение

nextIndex():
Возвращает индекс элемента, который будет возвращен следующим вызовом next()
Если итератор находится в конце списка, возвращает размер списка
Не изменяет состояние итератора

previousIndex():
Возвращает индекс элемента, который будет возвращен следующим вызовом previous()
Если итератор находится в начале списка, возвращает -1
Не изменяет состояние итератора

Математическая модель позиционирования

Для списка из n элементов с индексами от 0 до n-1:

Индексы элементов:   0     1     2     3
Позиции курсора:  0     1     2     3     4

Соотношения:
- nextIndex() возвращает индекс курсора
- previousIndex() возвращает (курсор - 1)
- hasNext() = (nextIndex() < n)
- hasPrevious() = (previousIndex() >= 0)

Внутренние механизмы реализации

Базовая реализация

// Концептуальная реализация
public int nextIndex() {
    return cursor;
}

public int previousIndex() {
    return cursor - 1;
}

Для ArrayList: Реализация тривиальна, так как позиция хранится как целочисленный индекс.
Для LinkedList: Требуется поддержка счетчика индекса или вычисление позиции через обход.

Поддержка индексации в LinkedList

В LinkedList итератору необходимо поддерживать информацию об индексе:

public int nextIndex() {
    return nextIndex;
}

public int previousIndex() {
    return nextIndex - 1;
}

Где nextIndex обновляется при каждом вызове next() или previous():
next(): увеличивает nextIndex на 1
previous(): уменьшает nextIndex на 1

Особенности производительности

Временная сложность: O(1) для обеих операций во всех реализациях.
Точность: Гарантированно точное значение индекса, соответствующее текущей позиции в списке.


#Java #для_новичков #beginner #ListIterator

Паттерны использования

Относительная навигация

public static <T> void processWithRelativeNavigation(List<T> list) {
    ListIterator<T> iterator = list.listIterator();
    
    while (iterator.hasNext()) {
        int currentIndex = iterator.nextIndex();
        T current = iterator.next();
        
        // Обработка с учетом позиции
        if (currentIndex % 2 == 0) {
            // Четная позиция
            processEvenPosition(current, currentIndex);
        }
        
        // Пропустить следующие 2 элемента, если возможно
        if (iterator.hasNext()) {
            iterator.next();
            if (iterator.hasNext()) {
                iterator.next();
            }
        }
    }
}

Валидация границ

public static <T> void safeBidirectionalProcessing(List<T> list) {
    ListIterator<T> iterator = list.listIterator();
    
    // Движение вперед с проверкой
    while (iterator.hasNext()) {
        int nextIdx = iterator.nextIndex();
        if (nextIdx < list.size() / 2) {
            // Только первая половина списка
            T element = iterator.next();
            processElement(element);
        } else {
            break;
        }
    }
    
    // Движение назад
    while (iterator.hasPrevious()) {
        int prevIdx = iterator.previousIndex();
        if (prevIdx >= 0) {
            T element = iterator.previous();
            reverseProcess(element);
        }
    }
}

Создание подсписков по позициям

public static <T> List<T> extractSubList(List<T> list, int startIndex, int endIndex) {
    List<T> result = new ArrayList<>();
    ListIterator<T> iterator = list.listIterator(startIndex);
    
    while (iterator.hasNext() && iterator.nextIndex() < endIndex) {
        result.add(iterator.next());
    }
    
    return result;
}

Расширенные методы модификации

set(E e): Замена текущего элемента

Концептуальное назначение
Метод set(E e) позволяет заменить последний элемент, возвращенный вызовом next() или previous(). Это расширяет возможности итератора за пределы простого удаления, позволяя модифицировать содержимое списка во время итерации.

Семантика и поведение
Условия вызова: Может быть вызван только после успешного вызова next() или previous().
Исключения: Выбрасывает IllegalStateException, если не был вызван next() или previous(), или если после последнего вызова next()/previous() был вызван add() или remove().
Эффект: Заменяет элемент в списке без изменения размера коллекции или позиции итератора.

Внутренние механизмы реализации

Общий алгоритм

public void set(E e) {
    if (lastReturned == null) {
        throw new IllegalStateException();
    }
    checkForComodification();
    
    try {
        // Замена элемента в списке
        list.set(lastReturnedIndex, e);
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

Реализация для ArrayList

public void set(E e) {
    if (lastReturned < 0) {
        throw new IllegalStateException();
    }
    checkForComodification();
    
    try {
        ArrayList.this.set(lastReturned, e);
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

Особенности:
Прямой доступ к массиву по индексу
Проверка границ массива
Сохранение позиции итератора

Реализация для LinkedList

public void set(E e) {
    if (lastReturned == null) {
        throw new IllegalStateException();
    }
    checkForComodification();
    lastReturned.item = e;
}

Особенности:
Прямая модификация поля item узла
Не требует поиска узла
Высокая эффективность

Особенности производительности

Временная сложность:
ArrayList: O(1) — прямой доступ по индексу
LinkedList: O(1) — модификация существующего узла
Память: Может создавать новый объект, если заменяемый элемент становится недостижимым.
Потокобезопасность: Не является потокобезопасным.


#Java #для_новичков #beginner #ListIterator

Паттерны использования

Модификация элементов на лету

public static void transformStrings(List<String> strings) {
    ListIterator<String> iterator = strings.listIterator();
    
    while (iterator.hasNext()) {
        String original = iterator.next();
        String transformed = original.toUpperCase();
        iterator.set(transformed);
    }
}

Условная замена

public static void replaceIf(List<Integer> numbers, Predicate<Integer> condition, Integer replacement) {
    ListIterator<Integer> iterator = numbers.listIterator();
    
    while (iterator.hasNext()) {
        Integer current = iterator.next();
        if (condition.test(current)) {
            iterator.set(replacement);
        }
    }
}

Коррекция данных

public static void correctDataSequence(List<DataPoint> data) {
    if (data.isEmpty()) return;
    
    ListIterator<DataPoint> iterator = data.listIterator();
    DataPoint previous = iterator.next();
    
    while (iterator.hasNext()) {
        DataPoint current = iterator.next();
        
        // Коррекция аномальных значений
        if (isAnomaly(current, previous)) {
            DataPoint corrected = interpolate(previous, current);
            iterator.set(corrected);
        }
        
        previous = current;
    }
}

add(E e): Вставка нового элемента

Концептуальное назначение
Метод add(E e) представляет собой наиболее мощную операцию ListIterator — он позволяет вставлять новые элементы в список непосредственно перед элементом, который будет возвращен следующим вызовом next(). Это уникальная возможность, недоступная в базовом Iterator.

Семантика и поведение

Позиция вставки: Элемент вставляется перед элементом, который будет возвращен next(), или в конец списка, если next() вернет NoSuchElementException.
Влияние на итератор: После вставки последующий вызов next() вернет новый элемент, а previous() вернет только что вставленный элемент.
Состояние: Сбрасывает состояние lastReturned, поэтому последующий вызов remove() или set() выбросит исключение до следующего вызова next() или previous().

Внутренние механизмы реализации

Общий алгоритм

public void add(E e) {
    checkForComodification();
    
    try {
        int i = cursor;
        // Вставка в список
        list.add(i, e);
        
        // Корректировка состояния итератора
        cursor = i + 1;
        lastReturned = null;
        nextIndex++;
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

Реализация для ArrayList

public void add(E e) {
    checkForComodification();
    
    try {
        int i = cursor;
        ArrayList.this.add(i, e);
        cursor = i + 1;
        lastReturned = null;
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

Особенности:
Вызов ArrayList.add(index, element) со сдвигом элементов
Корректировка курсора и счетчиков
Обработка возможного расширения массива

Реализация для LinkedList

public void add(E e) {
    checkForComodification();
    lastReturned = null;
    
    if (next == null) {
        // Вставка в конец
        linkLast(e);
    } else {
        // Вставка перед next
        linkBefore(e, next);
    }
    
    nextIndex++;
    expectedModCount++;
}

Особенности:
Эффективная вставка за O(1) после нахождения позиции
Манипуляции со ссылками между узлами
Автоматическая обработка граничных условий

Особенности производительности

Временная сложность:
ArrayList: O(n) — требуется сдвиг элементов
LinkedList: O(1) — вставка в найденную позицию
Память: Создает новый объект узла (LinkedList) или может вызвать расширение массива (ArrayList).
Потокобезопасность: Не является потокобезопасным.


#Java #для_новичков #beginner #ListIterator

                                                             BiFunction<T, T, T> lookaheadProcessor,
                                                             BiFunction<T, T, T> lookbehindProcessor) {
        if (list.size() < 2) return;
        
        ListIterator<T> iterator = list.listIterator();
        
        // Обработка с lookahead
        while (iterator.hasNext()) {
            int currentIndex = iterator.nextIndex();
            T current = iterator.next();
            
            if (iterator.hasNext()) {
                // Есть следующий элемент для lookahead
                T lookahead = iterator.next();
                T processed = lookaheadProcessor.apply(current, lookahead);
                
                // Возвращаемся и заменяем текущий элемент
                iterator.previous(); // К lookahead
                iterator.previous(); // К current
                iterator.set(processed);
                iterator.next(); // К lookahead
                iterator.next(); // К следующему элементу для продолжения
            }
        }
        
        // Обработка с lookbehind
        while (iterator.hasPrevious()) {
            T current = iterator.previous();
            
            if (iterator.hasPrevious()) {
                T lookbehind = iterator.previous();
                T processed = lookbehindProcessor.apply(current, lookbehind);
                
                // Возвращаемся и заменяем
                iterator.next(); // К lookbehind
                iterator.next(); // К current
                iterator.set(processed);
                iterator.previous(); // К lookbehind для продолжения
            }
        }
    }
}

Управление состоянием и переходы

Диаграмма состояний ListIterator

Состояния:
1. Инициализация: lastReturned = null, cursor = 0
2. После next(): lastReturned = элемент, cursor = nextIndex
3. После previous(): lastReturned = элемент, cursor = previousIndex + 1
4. После remove(): lastReturned = null
5. После set(): lastReturned остается установленным
6. После add(): lastReturned = null, cursor увеличивается на 1

Допустимые переходы:
- next() → remove() ✓, set() ✓, add() ✓
- previous() → remove() ✓, set() ✓, add() ✓
- remove() → next() ✓, previous() ✓, add() ✗, set() ✗, remove() ✗
- set() → next() ✓, previous() ✓, remove() ✗, add() ✗
- add() → next() ✓, previous() ✓, remove() ✗, set() ✗

Валидация последовательности операций

public class ListIteratorValidator {
    
    public static <T> boolean validateOperationSequence(ListIterator<T> iterator, 
                                                       List<String> operations) {
        boolean canRemoveOrSet = false;
        
        for (String op : operations) {
            switch (op) {
                case "next":
                    if (!iterator.hasNext()) return false;
                    iterator.next();
                    canRemoveOrSet = true;
                    break;
                    
                case "previous":
                    if (!iterator.hasPrevious()) return false;
                    iterator.previous();
                    canRemoveOrSet = true;
                    break;
                    
                case "remove":
                    if (!canRemoveOrSet) return false;
                    iterator.remove();
                    canRemoveOrSet = false;
                    break;
                    
                case "set":
                    if (!canRemoveOrSet) return false;
                    // Необходим элемент для замены
                    iterator.set(null); // Упрощенная проверка
                    canRemoveOrSet = false;
                    break;
                    
                case "add":
                    iterator.add(null); // Всегда допустимо
                    canRemoveOrSet = false;
                    break;
                    
                default:
                    return false;
            }
        }
        
        return true;
    }
}

#Java #для_новичков #beginner #ListIterator

Оптимизированные паттерны использования

Эффективное использование для ArrayList

public class ArrayListOptimizations {
    
    // Избегайте частых add() и remove() в середине списка
    public static void efficientArrayListProcessing(List<String> list) {
        // Вместо множественных add() через ListIterator
        // Собирайте изменения и применяйте их пакетно
        
        List<String> toAdd = new ArrayList<>();
        ListIterator<String> iterator = list.listIterator();
        
        while (iterator.hasNext()) {
            String current = iterator.next();
            if (shouldDuplicate(current)) {
                toAdd.add(current + "_copy");
            }
        }
        
        // Пакетное добавление в конец
        list.addAll(toAdd);
    }
    
    // Используйте set() вместо remove() + add() для замены
    public static void replaceEfficiently(List<Integer> numbers) {
        ListIterator<Integer> iterator = numbers.listIterator();
        
        while (iterator.hasNext()) {
            Integer current = iterator.next();
            if (current % 2 == 0) {
                iterator.set(current * 2); // Эффективнее, чем remove() + add()
            }
        }
    }
}

Эффективное использование для LinkedList

public class LinkedListOptimizations {
    
    // LinkedList идеально подходит для частых вставок/удалений через ListIterator
    public static void efficientLinkedListProcessing(LinkedList<String> list) {
        ListIterator<String> iterator = list.listIterator();
        
        // Частые вставки эффективны
        while (iterator.hasNext()) {
            String current = iterator.next();
            if (requiresPrefix(current)) {
                iterator.add("prefix_" + current);
            }
        }
        
        // Частые удаления также эффективны
        iterator = list.listIterator();
        while (iterator.hasNext()) {
            if (shouldRemove(iterator.next())) {
                iterator.remove();
            }
        }
    }
    
    // Использование previous() для навигации назад
    public static void findAndProcessFromEnd(LinkedList<String> list, String target) {
        ListIterator<String> iterator = list.listIterator(list.size());
        
        while (iterator.hasPrevious()) {
            String current = iterator.previous();
            if (current.equals(target)) {
                // Нашли - обрабатываем и можем идти в обе стороны
                processFound(current);
                
                // Можем продолжить в любом направлении
                if (iterator.hasPrevious()) {
                    processPrevious(iterator.previous());
                }
                if (iterator.hasNext()) {
                    processNext(iterator.next());
                }
                break;
            }
        }
    }
}

#Java #для_новичков #beginner #ListIterator

Best Practices

1. Выбор начальной позиции

// Начинайте с нужной позиции, а не всегда с начала
ListIterator<T> iterator = list.listIterator(startPosition);

// Для обработки с конца
ListIterator<T> reverseIterator = list.listIterator(list.size());

2. Минимизация переходов между next() и previous()

// Неэффективно:
while (iterator.hasNext()) {
    T current = iterator.next();
    if (condition(current)) {
        iterator.previous(); // Дорогой переход
        iterator.add(newElement);
        iterator.next(); // Еще один переход
        iterator.next(); // Пропускаем добавленный элемент
    }
}

// Более эффективно:
while (iterator.hasNext()) {
    T current = iterator.next();
    if (condition(current)) {
        iterator.add(newElement);
        // current остался тем же, newElement теперь перед ним
    }
}

3. Использование nextIndex()/previousIndex() для логики, зависящей от позиции

ListIterator<T> iterator = list.listIterator();
while (iterator.hasNext()) {
    int currentIndex = iterator.nextIndex();
    T element = iterator.next();
    
    if (currentIndex % 2 == 0) {
        // Обработка четных позиций
        processEven(element, currentIndex);
    }
}

4. Безопасность в многопоточных сценариях

// Всегда синхронизируйте доступ к ListIterator
synchronized(list) {
    ListIterator<T> iterator = list.listIterator();
    while (iterator.hasNext()) {
        // Обработка
    }
}

// Или используйте потокобезопасные альтернативы
List<T> syncList = Collections.synchronizedList(new ArrayList<>());
// Но даже synchronizedList требует внешней синхронизации для итерации

#Java #для_новичков #beginner #ListIterator

Predicates в Spring Cloud Gateway: Механика и расширяемость условий маршрутизации

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

Предикаты в Spring Cloud Gateway — это условия, определяющие, должен ли конкретный маршрут быть применён к входящему запросу. На архитектурном уровне предикаты реализуют паттерн Factory Method через абстракцию RoutePredicateFactory. Каждый предикат компилируется в объект Predicate<ServerWebExchange>, который затем оценивается в процессе сопоставления маршрута.


Процесс инициализации предиката

Когда приложение Spring Cloud Gateway стартует, происходит следующая последовательность:
Парсинг конфигурации: Конфигурационный файл (YAML или properties) читается, и определения предикатов преобразуются в объекты PredicateDefinition.
Поиск фабрик: Для каждого PredicateDefinition Spring ищет соответствующий bean типа RoutePredicateFactory. Имя фабрики определяется по свойству name в определении предиката.
Создание конфигурационного объекта: Фабрика создаёт конфигурационный объект (обычно static inner class), который заполняется значениями из аргументов предиката.
Генерация предиката: Вызывается метод apply() фабрики, который возвращает функциональный интерфейс Predicate<ServerWebExchange>.


Порядок оценки предикатов

Предикаты внутри маршрута оцениваются в порядке их объявления, но с важной оптимизацией: оценка происходит лениво и останавливается при первом false.

Механизм оценки реализован через цепочку вызовов and():

// Внутренняя реализация оценки предикатов маршрута
public boolean test(ServerWebExchange exchange) {
    for (Predicate<ServerWebExchange> predicate : predicates) {
        if (!predicate.test(exchange)) {
            return false; // Прерывание при первом false
        }
    }
    return true;
}

Детальный разбор встроенных предикатов

Path Predicate: эффективное сопоставление путей

Предикат Path — наиболее часто используемый. Внутри он использует PathPatternParser из Spring WebFlux, который компилирует строковые шаблоны в оптимизированные структуры данных.

Механика работы:

// Пример внутренней реализации
public class PathRoutePredicateFactory extends 
        AbstractRoutePredicateFactory<PathRoutePredicateFactory.Config> {
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        final PathPattern pattern = pathPatternParser.parse(config.getPattern());
        
        return exchange -> {
            PathContainer path = exchange.getRequest().getPath();
            PathPattern.PathMatchInfo info = pattern.matchAndExtract(path);
            
            if (info != null) {
                // Сохранение извлечённых переменных в атрибуты
                exchange.getAttributes().put(
                    PathPatternRoutePredicateHandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE,
                    info.getUriVariables()
                );
                return true;
            }
            return false;
        };
    }
}

Использование переменных пути:

predicates:
  - Path=/api/users/{id}/orders/{orderId}
Извлечённые переменные id и orderId доступны в фильтрах через шаблоны ${id} и ${orderId}.

Host Predicate: виртуальные хосты и шаблоны

Предикат Host позволяет маршрутизировать на основе заголовка Host или имени сервера.

Расширенные шаблоны:

predicates:
  - Host=**.example.com,{subdomain}.api.example.com

Шаблон {subdomain}.api.example.com извлекает поддомен как переменную.

Внутренне это преобразуется в регулярное выражение:

// Пример генерации паттерна
String pattern = "^(?<subdomain>[^.]+)\\.api\\.example\\.com$";

Query Predicate: параметры запроса

Предикат Query проверяет наличие и значение параметров URL.

Конфигурация с регулярными выражениями:

predicates:
  - Query=version,v[0-9]+\.[0-9]+  # Проверка формата версии
  - Query=token                     # Просто наличие параметра

Внутренняя реализация использует ServerWebExchange.getRequest().getQueryParams() для доступа к параметрам. Важно отметить, что параметры кэшируются после первого чтения для эффективности.


#Java #middle #Spring_Cloud_Gateway

RemoteAddr Predicate: контроль доступа по IP

Этот предикат проверяет IP-адрес клиента через CIDR-нотацию.

Механика работы:

public Predicate<ServerWebExchange> apply(Config config) {
    List<IpSubnetFilterRule> sources = config.getSources().stream()
        .map(IpSubnetFilterRule::new)
        .collect(Collectors.toList());
    
    return exchange -> {
        InetSocketAddress remoteAddress = exchange.getRequest()
            .getRemoteAddress();
        
        if (remoteAddress != null) {
            for (IpSubnetFilterRule source : sources) {
                if (source.matches(remoteAddress)) {
                    return true;
                }
            }
        }
        return false;
    };
}

Важные нюансы:
При использовании за прокси (nginx, load balancer) необходимо корректно настраивать X-Forwarded-For
IP-адрес извлекается из ServerHttpRequest.getRemoteAddress(), который может быть обёрткой для реального соединения


Weight Predicate: взвешенная маршрутизация

Предикат Weight используется для канареечных развёртываний и A/B тестирования. Он работает в паре: один маршрут определяет группу, а другие маршруты распределяют вес внутри группы.

Конфигурация:

spring:
  cloud:
    gateway:
      routes:
      - id: weight_high
        uri: https://weighthigh.example.org
        predicates:
        - Path=/api/**
        - Weight=group1, 80
        metadata:
          response-timeout: 3000
      
      - id: weight_low
        uri: https://weightlow.example.org
        predicates:
        - Path=/api/**
        - Weight=group1, 20
        metadata:
          response-timeout: 5000

Внутренняя механика:
При инициализации создаётся общий AtomicInteger для группы
Для каждого запроса вычисляется хэш (обычно на основе пути и/или заголовков)
Хэш мапируется на диапазон весов для выбора маршрута
Выбор детерминирован для одинаковых хэшей, что обеспечивает согласованную маршрутизацию


Method Predicate: фильтрация по HTTP-методам

Простейший, но эффективный предикат для ограничения доступа:

predicates:
  - Method=GET,POST,OPTIONS
Внутренне преобразуется в проверку exchange.getRequest().getMethod().

Сложные комбинации через AND/OR

Spring Cloud Gateway поддерживает логические комбинации предикатов через DSL и конфигурацию.


Комбинации через YAML

В YAML предикаты по умолчанию объединяются через логическое И (AND):

predicates:
  - Path=/api/**
  - Method=GET
  - Header=X-API-Key,.*
  - Query=version,v2

Все четыре условия должны быть истинны для применения маршрута.


Логическое ИЛИ через кастомный предикат

Для реализации ИЛИ необходимо создать составной предикат:

@Component
public class OrRoutePredicateFactory extends 
        AbstractRoutePredicateFactory<OrRoutePredicateFactory.Config> {
    
    public OrRoutePredicateFactory() {
        super(Config.class);
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            for (PredicateDefinition def : config.getPredicates()) {
                RoutePredicateFactory factory = findFactory(def);
                if (factory != null && factory.apply(convert(def)).test(exchange)) {
                    return true;
                }
            }
            return false;
        };
    }
    
    public static class Config {
        private List<PredicateDefinition> predicates = new ArrayList<>();
        // геттеры и сеттеры
    }
}

Использование в YAML:

predicates:
  - name: Or
    args:
      predicates:
        - name: Path
          args:
            pattern: /api/v1/**
        - name: Path
          args:
            pattern: /legacy/api/**

Негация (NOT) через After с отрицанием

Прямой поддержки NOT нет, но можно использовать временные предикаты с отрицанием:

public Predicate<ServerWebExchange> apply(Config config) {
    return exchange -> {
        // Инвертирование любого предиката
        return !delegatePredicate.test(exchange);
    };
}

#Java #middle #Spring_Cloud_Gateway

Создание кастомного предиката

Реализация RoutePredicateFactory

Создание кастомного предиката требует реализации интерфейса RoutePredicateFactory:

@Component
public class JwtClaimRoutePredicateFactory extends 
        AbstractRoutePredicateFactory<JwtClaimRoutePredicateFactory.Config> {
    
    private final JwtDecoder jwtDecoder;
    
    public JwtClaimRoutePredicateFactory(JwtDecoder jwtDecoder) {
        super(Config.class);
        this.jwtDecoder = jwtDecoder;
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            // Извлечение JWT из заголовка
            String authHeader = exchange.getRequest()
                .getHeaders()
                .getFirst(HttpHeaders.AUTHORIZATION);
            
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                return false;
            }
            
            String token = authHeader.substring(7);
            
            try {
                // Декодирование и проверка claims
                Jwt jwt = jwtDecoder.decode(token);
                
                // Проверка конкретного claim
                String claimValue = jwt.getClaimAsString(config.getClaimName());
                
                if (claimValue == null) {
                    return false;
                }
                
                // Сопоставление с ожидаемым значением
                if (config.getPattern() != null) {
                    return claimValue.matches(config.getPattern());
                }
                
                return config.getExpectedValues()
                    .stream()
                    .anyMatch(expected -> expected.equals(claimValue));
                
            } catch (JwtException e) {
                return false;
            }
        };
    }
    
    // Конфигурационный класс
    public static class Config {
        private String claimName;
        private String pattern;
        private List<String> expectedValues = new ArrayList<>();
        
        // Геттеры и сеттеры
        public String getClaimName() {
            return claimName;
        }
        
        public void setClaimName(String claimName) {
            this.claimName = claimName;
        }
        
        public String getPattern() {
            return pattern;
        }
        
        public void setPattern(String pattern) {
            this.pattern = pattern;
        }
        
        public List<String> getExpectedValues() {
            return expectedValues;
        }
        
        public void setExpectedValues(List<String> expectedValues) {
            this.expectedValues = expectedValues;
        }
    }
    
    // Короткая форма конфигурации
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("claimName", "pattern");
    }
}

#Java #middle #Spring_Cloud_Gateway

Регистрация и использование

Spring Boot автоматически обнаружит компонент через аннотацию @Component.

Для использования в YAML:

predicates:
  - name: JwtClaim
    args:
      claimName: roles
      expectedValues: admin,superuser

Или в краткой форме, если реализован shortcutFieldOrder():

predicates:
  - JwtClaim=roles,admin|superuser

Предикат с динамической конфигурацией

Для предикатов, требующих внешней конфигурации или состояния:

@Component
public class RateLimitPredicateFactory extends 
        AbstractRoutePredicateFactory<RateLimitPredicateFactory.Config> 
        implements ApplicationListener<EnvironmentChangeEvent> {
    
    private final RateLimiter rateLimiter;
    private final Map<String, Config> configCache = new ConcurrentHashMap<>();
    
    public RateLimitPredicateFactory(RateLimiter rateLimiter) {
        super(Config.class);
        this.rateLimiter = rateLimiter;
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        // Кэширование конфигурации для производительности
        String cacheKey = config.getClientId() + ":" + config.getLimit();
        configCache.put(cacheKey, config);
        
        return exchange -> {
            Config cachedConfig = configCache.get(cacheKey);
            
            // Извлечение идентификатора клиента из запроса
            String clientId = extractClientId(exchange);
            
            if (clientId == null || !clientId.equals(cachedConfig.getClientId())) {
                return false;
            }
            
            // Проверка лимита
            return rateLimiter.tryAcquire(clientId, cachedConfig.getLimit());
        };
    }
    
    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        // Очистка кэша при изменении конфигурации
        configCache.clear();
    }
    
    private String extractClientId(ServerWebExchange exchange) {
        // Логика извлечения clientId из запроса
        return exchange.getRequest().getHeaders()
            .getFirst("X-Client-Id");
    }
    
    public static class Config {
        private String clientId;
        private int limit;
        
        // Геттеры и сеттеры
    }
}

Асинхронные предикаты

Для предикатов, требующих асинхронных операций (обращение к БД, внешним API):

@Component
public class ExternalServicePredicateFactory extends 
        AbstractRoutePredicateFactory<ExternalServicePredicateFactory.Config> {
    
    private final WebClient webClient;
    
    @Override
    public AsyncPredicate<ServerWebExchange> applyAsync(Config config) {
        return exchange -> {
            // Асинхронная проверка через внешний сервис
            return webClient.post()
                .uri(config.getValidationUrl())
                .bodyValue(buildValidationRequest(exchange))
                .retrieve()
                .bodyToMono(ValidationResponse.class)
                .map(response -> response.isValid())
                .onErrorReturn(false); // При ошибке считаем предикат false
        };
    }
    
    public static class Config {
        private String validationUrl;
        private int timeoutMs = 1000;
        
        // Геттеры и сеттеры
    }
}

Асинхронные предикаты возвращают AsyncPredicate<ServerWebExchange>, который оценивается в реактивном контексте и не блокирует event loop threads.


#Java #middle #Spring_Cloud_Gateway

Производительность и оптимизации

Кэширование вычислений предикатов

Для дорогих предикатов важно кэшировать результаты:

public Predicate<ServerWebExchange> apply(Config config) {
    LoadingCache<ServerWebExchange, Boolean> cache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(1, TimeUnit.MINUTES)
        .build(exchange -> computeExpensivePredicate(exchange, config));
    
    return exchange -> {
        try {
            return cache.get(exchange);
        } catch (Exception e) {
            return false;
        }
    };
}

Порядок предикатов для оптимизации

Располагайте предикаты в порядке возрастания вычислительной сложности:

predicates:
  - Method=GET              # Быстрая проверка
  - Path=/api/**            # Умеренная сложность
  - Query=token,.*          # Простая проверка параметра
  - JwtClaim=roles,admin   # Дорогая проверка JWT

Это позволяет отсеивать неподходящие запросы до выполнения дорогих операций.

Мониторинг и метрики

Интеграция с Micrometer для мониторинга эффективности предикатов:

public Predicate<ServerWebExchange> apply(Config config) {
    Counter matchCounter = meterRegistry.counter(
        "gateway.predicate.matches",
        "predicate", config.getName()
    );
    
    Counter totalCounter = meterRegistry.counter(
        "gateway.predicate.checks",
        "predicate", config.getName()
    );
    
    Timer timer = meterRegistry.timer(
        "gateway.predicate.duration",
        "predicate", config.getName()
    );
    
    return exchange -> {
        totalCounter.increment();
        
        return timer.record(() -> {
            boolean matches = internalTest(exchange, config);
            if (matches) {
                matchCounter.increment();
            }
            return matches;
        });
    };
}

#Java #middle #Spring_Cloud_Gateway

Глава 6. Итераторы

Циклы for-each, индексированный for и семантика fail-fast/fail-safe коллекций

Концептуальные основы for-each

Цикл for-each (также известный как enhanced for loop) был введен в Java 5 как синтаксический сахар над стандартными итераторами. Он предоставляет более чистый и читаемый способ обхода коллекций и массивов, скрывая сложности управления итератором от разработчика.

Синтаксис и семантика

for (Type element : collection) {
    // Обработка element
}

Механизм преобразования

Для массивов

Компилятор преобразует цикл for-each для массивов в стандартный индексированный цикл:

// Исходный код
for (String item : array) {
    process(item);
}

// Преобразуется в
for (int i = 0; i < array.length; i++) {
    String item = array[i];
    process(item);
}

Для коллекций, реализующих Iterable

Для объектов, реализующих интерфейс Iterable<T>, компилятор генерирует код с использованием итератора:

// Исходный код
for (String item : collection) {
    process(item);
}

// Преобразуется в
for (Iterator<String> iterator = collection.iterator(); iterator.hasNext(); ) {
    String item = iterator.next();
    process(item);
}

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

Интерфейс Iterable

Для использования в цикле for-each класс должен реализовывать интерфейс Iterable<T>:

public interface Iterable<T> {
    Iterator<T> iterator();
}

Этот интерфейс требует реализации единственного метода iterator(), возвращающего объект Iterator.

Исключения и ограничения

Поддерживаемые типы:
Массивы любых типов
Все классы, реализующие Iterable<T>
Коллекции из Java Collections Framework

Ограничения:
Нельзя получить доступ к индексу текущего элемента
Нельзя модифицировать коллекцию во время итерации (за исключением Iterator.remove())
Поддерживается только последовательный обход вперед

Внутренние механизмы работы

Генерация байт-кода
Компилятор Java генерирует специфичный байт-код для циклов for-each.

Для коллекций:

// Псевдокод байт-кода
INVOKEINTERFACE java/lang/Iterable.iterator()Ljava/util/Iterator;
ASTORE iterator
GOTO condition
loop:
 ALOAD iterator
 INVOKEINTERFACE java/util/Iterator.next()Ljava/lang/Object;
 // Обработка элемента
condition:
 ALOAD iterator
 INVOKEINTERFACE java/util/Iterator.hasNext()Z
 IFNE loop

Особенности:
Автоматическое создание и управление итератором
Обработка исключений NoSuchElementException
Автоматическое закрытие ресурсов для AutoCloseable объектов

Оптимизации времени выполнения

JVM применяет несколько оптимизаций для циклов for-each:
Inlining: Частые вызовы методов итератора могут быть inline-ированы.
Loop unrolling: Для малых массивов цикл может быть развернут.
Escape analysis: Временные объекты могут размещаться на стеке.

Преимущества и недостатки

Преимущества
Читаемость: Более чистый и выразительный синтаксис
Безопасность: Автоматическое управление итератором, исключение ошибок индексации
Универсальность: Работает с массивами и любыми Iterable коллекциями
Меньше boilerplate кода: Не требуется явное создание итератора

Недостатки
Ограниченный контроль: Нет доступа к индексу, нельзя модифицировать коллекцию
Односторонний обход: Только последовательное движение вперед
Производительность: Незначительный overhead по сравнению с индексированным циклом для массивов


#Java #для_новичков #beginner #for_each #fail_fast #fail_safe

Паттерны использования

Стандартный обход коллекций

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Явное использование итератора
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    System.out.println(name);
}

// Эквивалентный for-each
for (String name : names) {
    System.out.println(name);
}

Работа с вложенными коллекциями

List<List<Integer>> matrix = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);

// Вложенные for-each
for (List<Integer> row : matrix) {
    for (Integer value : row) {
        System.out.print(value + " ");
    }
    System.out.println();
}

Обход массивов

int[] numbers = {1, 2, 3, 4, 5};

// Традиционный for
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// For-each
for (int number : numbers) {
    System.out.println(number);
}

Индексированный цикл for: полный контроль над итерацией

Концептуальные основы

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

Синтаксис и структура

for (инициализация; условие; инкремент) {
    // Тело цикла
}

Механизм выполнения

Фазы выполнения
Инициализация: Выполняется один раз перед началом цикла
Проверка условия: Выполняется перед каждой итерацией
Выполнение тела: Если условие истинно
Инкремент: Выполняется после каждой итерации
Возврат к шагу 2

Байт-код представление

// Псевдокод байт-кода
ICONST_0
ISTORE index
GOTO condition
loop:
 // Тело цикла
 ILOAD index
 ICONST_1
 IADD
 ISTORE index
condition:
 ILOAD index
 array_length
 IF_ICMPLT loop

Варианты использования

Стандартный последовательный обход

List<String> list = new ArrayList<>();
// ... инициализация

for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    process(element);
}

Обратный обход

for (int i = list.size() - 1; i >= 0; i--) {
    String element = list.get(i);
    process(element);
}

Обход с шагом

for (int i = 0; i < list.size(); i += 2) {
    String element = list.get(i);
    process(element);
}

Множественные переменные цикла

for (int i = 0, j = 10; i < 10 && j > 0; i++, j--) {
    System.out.println("i=" + i + ", j=" + j);
}

Производительность и оптимизации

Для ArrayList:

// For-each (опосредованно через итератор)
for (String item : arrayList) {
    process(item);
}

// Индексированный for
for (int i = 0; i < arrayList.size(); i++) {
    String item = arrayList.get(i);
    process(item);
}

Производительность:
For-each: Создание итератора + вызовы hasNext()/next()
Индексированный for: Прямой доступ по индексу + boundary checking

Для LinkedList:

// For-each (эффективно)
for (String item : linkedList) {
    process(item);
}

// Индексированный for (неэффективно!)
for (int i = 0; i < linkedList.size(); i++) {
    String item = linkedList.get(i); // O(n) для каждого вызова!
    process(item);
}

Производительность:
For-each: O(n) общее время
Индексированный for: O(n²) из-за последовательного поиска элементов

Особые техники и паттерны

Пакетная обработка

int batchSize = 50;
for (int i = 0; i < data.size(); i += batchSize) {
    int end = Math.min(i + batchSize, data.size());
    List<Item> batch = data.subList(i, end);
    processBatch(batch);
}

Обход с модификацией

// Удаление элементов во время обхода (только для ArrayList)
for (int i = 0; i < list.size(); i++) {
    if (shouldRemove(list.get(i))) {
        list.remove(i);
        i--; // Корректировка индекса после удаления
    }
}

Параллельная обработка индексов

// Обработка двух коллекций одновременно
for (int i = 0; i < Math.min(list1.size(), list2.size()); i++) {
    processPair(list1.get(i), list2.get(i));
}

#Java #для_новичков #beginner #for_each #fail_fast #fail_safe

Рекомендации по выбору

Когда использовать for-each:
Простой последовательный обход без необходимости модификации
Работа с LinkedList или другими не-RandomAccess коллекциями
Улучшение читаемости кода
Обход массивов когда индекс не нужен
Работа с вложенными структурами

// Идеальный сценарий для for-each
for (Customer customer : customers) {
    sendNotification(customer);
}

Когда использовать индексированный for:
Необходимость доступа к индексу
Обратный или нестандартный обход
Модификация коллекции во время итерации
Пакетная обработка с определенным шагом
Работа с ArrayList или массивами

// Идеальный сценарий для индексированного for
for (int i = 0; i < array.length; i++) {
    if (array[i] == null) {
        array[i] = defaultValue;
    }
}

Гибридные подходы

Использование счетчика с for-each

int index = 0;
for (String item : collection) {
    processWithIndex(item, index);
    index++;
}

Обход с ListIterator

ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    int index = iterator.previousIndex();
    processWithIndex(item, index);
}

Fail-fast коллекции: философия быстрого отказа

Концепция fail-fast

Fail-fast (быстрый отказ) — это подход к обработке ошибок, при котором система немедленно сообщает о проблеме, как только она обнаружена. В контексте коллекций Java это означает, что итераторы обнаруживают структурные модификации коллекции во время итерации и немедленно выбрасывают исключение.

Механизм реализации

Ключевым элементом fail-fast поведения является поле modCount:

// Пример из AbstractList
protected transient int modCount = 0;

Назначение: Отслеживание количества структурных модификаций коллекции.
Инкрементация: Увеличивается при каждой операции, изменяющей размер или структуру коллекции.
Использование: Сравнивается с сохраненной копией в итераторе.

Реализация в итераторах

private class Itr implements Iterator<E> {
    int expectedModCount = modCount;
    int cursor = 0;
    
    public E next() {
        checkForComodification(); // Проверка изменений
        // ... остальная логика
    }
    
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
    
    public void remove() {
        checkForComodification();
        // ... удаление элемента
        expectedModCount = modCount; // Синхронизация после успешного удаления
    }
}

Коллекции с fail-fast семантикой
ArrayList и все его производные
LinkedList
HashSet
HashMap (итераторы entrySet, keySet, values)
TreeMap и TreeSet

Пример поведения

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

// Попытка модификации во время итерации
for (String item : list) {
    if (item.equals("B")) {
        list.remove(item); // ConcurrentModificationException!
    }
}

Детальный анализ исключения ConcurrentModificationException

Условия возникновения
Структурная модификация: Изменение размера коллекции (add, remove)
Одновременная итерация: Активный итератор или for-each цикл
Разные объекты: Модификация не через текущий итератор

Что считается структурной модификацией

Вызывают исключение:
add(), addAll()
remove(), removeAll(), retainAll(), clear()
set() на определенных позициях в некоторых реализациях

Не вызывают исключение:
set() для замены элемента без изменения размера
Операции через Iterator.remove()
Операции через ListIterator.add(), set(), remove()

Механизм обнаружения изменений

// Упрощенная проверка в ArrayList.Itr
final void checkForComodification() {
    if (modCount != expectedModCount) {
        // Разные стратегии в разных коллекциях
        if (modCount == expectedModCount + 1 && lastRet < 0) {
            // Возможно, это наш собственный remove()
            expectedModCount = modCount;
        } else {
            throw new ConcurrentModificationException();
        }
    }
}

#Java #для_новичков #beginner #for_each #fail_fast #fail_safe

Стратегии работы с fail-fast коллекциями

Безопасные паттерны

Использование Iterator.remove():

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    if (shouldRemove(item)) {
        iterator.remove(); // Безопасно!
    }
}

Сбор элементов для удаления:

List<String> toRemove = new ArrayList<>();
for (String item : list) {
    if (shouldRemove(item)) {
        toRemove.add(item);
    }
}
list.removeAll(toRemove); // Безопасно вне цикла

Использование индексированного цикла:

for (int i = 0; i < list.size(); i++) {
    if (shouldRemove(list.get(i))) {
        list.remove(i);
        i--; // Корректировка индекса
    }
}

Опасные паттерны (антипаттерны)

Модификация через коллекцию во время итерации:

for (String item : list) {
    list.add("new"); // ConcurrentModificationException!
}

Параллельные модификации из разных потоков:

// Поток 1
for (String item : list) {
    // Итерация
}

// Поток 2
list.add("new"); // ConcurrentModificationException в потоке 1

Преимущества и недостатки fail-fast подхода

Преимущества
Раннее обнаружение ошибок: Проблемы выявляются сразу же
Предсказуемость: Гарантированная consistency во время итерации
Простота отладки: Точное указание на проблему
Защита от тонких багов: Предотвращение незаметной порчи данных

Недостатки
Ограничения на модификации: Нельзя изменять коллекцию во время итерации
Производительность: Дополнительные проверки на каждой операции
Сложность в многопоточных сценариях: Требует внешней синхронизации


Fail-safe коллекции: философия безопасного продолжения

Fail-safe (безопасный отказ) — это подход, при котором система продолжает работу даже при возникновении ошибок или изменений состояния. В контексте коллекций это означает, что итераторы работают с моментальным снимком (snapshot) данных или используют специальные механизмы для обеспечения consistency во время итерации.


Механизмы реализации

Copy-on-write (копирование при записи)
Наиболее распространенный механизм fail-safe:

public class CopyOnWriteArrayList<E> {
    private transient volatile Object[] array;
    
    public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0);
    }
    
    static final class COWIterator<E> implements ListIterator<E> {
        private final Object[] snapshot;
        private int cursor;
        
        COWIterator(Object[] elements, int initialCursor) {
            snapshot = elements; // Снимок на момент создания
            cursor = initialCursor;
        }
        
        public E next() {
            if (!hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }
    }
}

Слабая согласованность (weakly consistent)

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

Коллекции с fail-safe семантикой

CopyOnWriteArrayList
Принцип работы: При каждой модификации создается новая копия внутреннего массива.

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// Безопасная модификация во время итерации
for (String item : list) { // Итератор использует snapshot
    if (condition(item)) {
        list.add("new"); // Не влияет на текущую итерацию
    }
}

ConcurrentHashMap
Принцип работы: Сегментированная блокировка и слабо-консистентные итераторы.

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// Итерация по entrySet
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    map.put("newKey", 42); // Безопасно, но может не отобразиться в текущем итераторе
}

ConcurrentLinkedQueue
Принцип работы: Lock-free алгоритмы и weak consistency.

ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

for (String item : queue) {
    queue.offer("new"); // Безопасно
}

#Java #для_новичков #beginner #for_each #fail_fast #fail_safe

Детальный анализ поведения fail-safe коллекций

CopyOnWriteArrayList: детали реализации
Структура данных:

public class CopyOnWriteArrayList<E> {
    // volatile для обеспечения memory visibility
    private transient volatile Object[] array;
    
    final Object[] getArray() {
        return array;
    }
    
    final void setArray(Object[] a) {
        array = a;
    }
}

Алгоритм добавления элемента:

public boolean add(E e) {
    synchronized(lock) {
        Object[] elements = getArray();
        int len = elements.length;
        
        // Создание новой копии
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        
        // Атомарная замена ссылки
        setArray(newElements);
        return true;
    }
}

Характеристики:
Чтение: O(1), без блокировок
Запись: O(n), требует полного копирования
Память: Дополнительная копия во время модификации
Итераторы: Всегда работают с snapshot

ConcurrentHashMap: сегментированная архитектура

Структура (Java 7 и ранее):

public class ConcurrentHashMap<K, V> {
    final Segment<K,V>[] segments; // Массив сегментов
    
    static final class Segment<K,V> extends ReentrantLock {
        transient volatile HashEntry<K,V>[] table;
    }
}

Итерация:

public Iterator<Map.Entry<K,V>> iterator() {
    return new EntryIterator();
}

// Weakly consistent итератор
final class EntryIterator extends HashIterator
    implements Iterator<Entry<K,V>> {
    public Map.Entry<K,V> next() {
        HashEntry<K,V> e = super.nextEntry();
        return new WriteThroughEntry(e.key, e.value);
    }
}

Характеристики:
Чтение: O(1) в среднем, без блокировок
Запись: O(1) в среднем, блокировка только сегмента
Итераторы: Weakly consistent, могут не видеть все изменения

Преимущества и недостатки fail-safe подхода

Преимущества
Безопасность в многопоточных сценариях: Нет необходимости во внешней синхронизации
Отсутствие ConcurrentModificationException: Итерация никогда не прерывается
Высокая производительность чтения: Особенно в read-heavy workload'ах
Простота использования: Меньше требований к синхронизации

Недостатки
Расход памяти: Copy-on-write требует дополнительной памяти
Задержка видимости изменений: Итераторы могут не видеть свежие данные
Производительность записи: Copy-on-write имеет высокую стоимость
Сложность семантики: Weak consistency может быть неинтуитивной

Паттерны использования fail-safe коллекций

Сценарии для CopyOnWriteArrayList
Конфигурационные данные:

public class ConfigurationManager {
    private final CopyOnWriteArrayList<Listener> listeners = 
        new CopyOnWriteArrayList<>();
    
    public void addListener(Listener listener) {
        listeners.add(listener); // Безопасно, даже во время уведомлений
    }
    
    public void notifyListeners() {
        for (Listener listener : listeners) { // Snapshot итератор
            listener.onChange();
        }
    }
}

Кэширование часто читаемых данных:

public class DataCache {
    private volatile CopyOnWriteArrayList<Data> cache = 
        new CopyOnWriteArrayList<>();
    
    public void refreshCache() {
        List<Data> newData = loadData();
        cache = new CopyOnWriteArrayList<>(newData); // Атомарная замена
    }
    
    public List<Data> getData() {
        return cache; // Безопасное чтение
    }
}

Сценарии для ConcurrentHashMap
Кэш с конкурентным доступом:

public class ConcurrentCache<K, V> {
    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();
    
    public V get(K key) {
        return cache.get(key); // Без блокировок
    }
    
    public V computeIfAbsent(K key, Function<K, V> loader) {
        return cache.computeIfAbsent(key, loader); // Атомарно
    }
    
    public void processAll() {
        for (Map.Entry<K, V> entry : cache.entrySet()) {
            // Безопасная итерация даже при concurrent модификациях
            processEntry(entry);
        }
    }
}

#Java #для_новичков #beginner #for_each #fail_fast #fail_safe

Критерии выбора fail-fast и fail-safe

Выбор fail-fast коллекций когда:
Single-threaded окружение или контролируемая многопоточность
Важна немедленная видимость изменений
Ограниченные ресурсы памяти
Частые операции записи
Нужна предсказуемость поведения

// Оптимально для single-threaded сценариев
List<String> singleThreadedList = new ArrayList<>();

Выбор fail-safe коллекций когда:
Высокая конкурентность чтения и записи
Read-heavy workloads
Не критична задержка видимости изменений
Достаточно памяти для copy-on-write
Нужна thread-safe семантика без внешней синхронизации

// Оптимально для многопоточных read-heavy сценариев
List<String> concurrentList = new CopyOnWriteArrayList<>();

Гибридные подходы

Комбинация fail-fast и внешней синхронизации

public class SynchronizedListWrapper {
    private final List<String> list = new ArrayList<>();
    
    public synchronized void safeIteration() {
        // Внутри synchronized блока fail-fast безопасен
        for (String item : list) {
            process(item);
        }
    }
    
    public synchronized void modify() {
        list.add("new");
    }
}

Использование ReadWriteLock

public class ReadWriteProtectedList {
    private final List<String> list = new ArrayList<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void iterateSafely() {
        lock.readLock().lock();
        try {
            for (String item : list) {
                process(item); // Безопасное чтение
            }
        } finally {
            lock.readLock().unlock();
        }
    }
    
    public void modifySafely() {
        lock.writeLock().lock();
        try {
            list.add("new"); // Безопасная модификация
        } finally {
            lock.writeLock().unlock();
        }
    }
}

Практические рекомендации и best practices

Общие рекомендации по выбору циклов
Предпочитайте for-each для простого последовательного обхода
Используйте индексированный for когда нужен индекс или нестандартный обход
Избегайте индексированного for для LinkedList
Рассмотрите Stream API для сложных операций фильтрации и трансформации

// For-each для простого обхода
for (Item item : items) {
    process(item);
}

// Индексированный for когда нужен индекс
for (int i = 0; i < items.size(); i++) {
    processWithIndex(items.get(i), i);
}

// Stream API для сложных операций
items.stream()
     .filter(this::shouldProcess)
     .map(this::transform)
     .forEach(this::process);

Рекомендации по работе с fail-fast коллекциями
Не модифицируйте коллекцию во время итерации через методы коллекции
Используйте Iterator.remove() для безопасного удаления
Собирайте изменения отдельно для пакетного применения
Синхронизируйте доступ в многопоточных сценариях

// Безопасный паттерн
List<String> toRemove = new ArrayList<>();
for (String item : list) {
    if (shouldRemove(item)) {
        toRemove.add(item);
    }
}
list.removeAll(toRemove);

Рекомендации по работе с fail-safe коллекциями
Понимайте семантику weak consistency для concurrent коллекций
Учитывайте стоимость copy-on-write для больших коллекций
Используйте для read-heavy workloads
Избегайте частых модификаций больших CopyOnWriteArrayList

// Оптимальное использование CopyOnWriteArrayList
CopyOnWriteArrayList<Data> dataCache = new CopyOnWriteArrayList<>();

// Редкое обновление всего кэша
public void refreshCache() {
    List<Data> freshData = loadFreshData();
    dataCache = new CopyOnWriteArrayList<>(freshData);
}

// Частое чтение
public List<Data> getCachedData() {
    return dataCache;
}

#Java #для_новичков #beginner #for_each #fail_fast #fail_safe