predicates:
  - Path=/api/users/** 

.route("users", r -> r.path("/api/users/**")
                     .uri("lb://user-service"))

predicates:
  - Host=api.example.com, *.internal.example.org

.route("host-route", r -> r.host("api.example.com", "*.internal.example.org")
                           .uri("http://localhost:8080"))

predicates:
  - Method=GET,POST

.route("read-write", r -> r.method(HttpMethod.GET, HttpMethod.POST)
                           .uri("lb://some-service"))

predicates:
  - Header=X-Client, ^mobile-.*

.route("header-route", r -> r.header("X-Client", "^mobile-.*")
                              .uri("http://mobile-backend"))

predicates:
  - Query=version, ^v[0-9]+$

.route("versioned", r -> r.query("version", "^v[0-9]+$")
                           .uri("lb://versioned-service"))

predicates:
  - RemoteAddr=192.168.1.0/24, 10.0.0.10

.route("internal-only", r -> r.remoteAddr("192.168.0.0/16", "10.0.0.0/8")
                              .uri("lb://internal-service"))

import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.web.server.ServerWebExchange;
import java.util.function.Predicate;
import java.util.List;

public class XFeatureRoutePredicateFactory extends AbstractRoutePredicateFactory<XFeatureRoutePredicateFactory.Config> {

    public XFeatureRoutePredicateFactory() {
        super(Config.class);
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        List<String> allowed = config.getAllowedValues();
        boolean ignoreCase = config.isIgnoreCase();

        return exchange -> {
            List<String> headerValues = exchange.getRequest().getHeaders().get("X-Feature");
            if (headerValues == null || headerValues.isEmpty()) {
                return false;
            }
            for (String hv : headerValues) {
                for (String allowedVal : allowed) {
                    if (ignoreCase) {
                        if (hv.equalsIgnoreCase(allowedVal)) return true;
                    } else {
                        if (hv.equals(allowedVal)) return true;
                    }
                }
            }
            return false;
        };
    }

    public static class Config {
        private List<String> allowedValues;
        private boolean ignoreCase = true;

        public List<String> getAllowedValues() { return allowedValues; }
        public void setAllowedValues(List<String> allowedValues) { this.allowedValues = allowedValues; }
        public boolean isIgnoreCase() { return ignoreCase; }
        public void setIgnoreCase(boolean ignoreCase) { this.ignoreCase = ignoreCase; }
    }
}

import org.springframework.stereotype.Component;

@Component
public class XFeatureRoutePredicateFactory extends AbstractRoutePredicateFactory<XFeatureRoutePredicateFactory.Config> {
    // ... код как выше
}

spring:
  cloud:
    gateway:
      routes:
        - id: feature-route
          uri: http://feature-service
          predicates:
            - XFeature=allowed1,allowed2

.route("xfeature-inline", r -> r.p(exchange -> {
    List<String> values = exchange.getRequest().getHeaders().get("X-Feature");
    return values != null && values.stream().anyMatch(v -> v.equalsIgnoreCase("allowed1"));
}).uri("http://feature-service"))

routes:
  - id: users-route
    uri: lb://user-service
    predicates:
      - Host=api.example.com
      - Path=/users/** 
      - Method=GET

Пояснение: типичный маршрут, дешёвые проверки (Host/Method/Path) — быстрый short-circuit.

routes:
  - id: mobile-route
    uri: lb://mobile-backend
    predicates:
      - Header=X-Client, ^mobile-.*
      - Path=/api/**
  - id: fallback-route
    uri: lb://web-backend
    predicates:
      - Path=/api/**

Пояснение: первый маршрут отведёт мобильный трафик на mobile-backend; второй поймает остальные запросы по тому же Path — это простой способ построить OR-поведение без кастомных предикатов.

predicates:
  - XFeature=allowedA,allowedB

(см. реализацию XFeatureRoutePredicateFactory выше).

public class Task111225 {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        Integer c = 200;
        Integer d = 200;
        
        System.out.print((a == b) + " ");
        System.out.print((c == d) + " ");
        
        int e = 200;
        Integer f = 200;
        
        System.out.print((e == f) + " ");
        System.out.print((c == e));
    }
}

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);
}

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

// Концептуальная реализация для 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];
}

// Концептуальная реализация для 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;
}

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(); // Возвращаемся к текущему для продолжения
    }
}

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

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

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

public int nextIndex() {
    return nextIndex;
}

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

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;
}

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

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

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

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;
    }
}

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();
    }
}

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();
    }
}

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

public static void expandListWithPrimes(List<Integer> numbers) {
    ListIterator<Integer> iterator = numbers.listIterator();
    
    while (iterator.hasNext()) {
        Integer current = iterator.next();
        
        if (isPrime(current)) {
            // Вставляем квадрат простого числа перед ним
            iterator.previous(); // Возвращаемся к простому числу
            iterator.add(current * current);
            iterator.next(); // Продолжаем с исходного элемента
        }
    }
}

public static void interpolateMissing(List<Double> values) {
    if (values.size() < 2) return;
    
    ListIterator<Double> iterator = values.listIterator();
    Double prev = iterator.next();
    
    while (iterator.hasNext()) {
        Double current = iterator.next();
        
        if (current == null && prev != null) {
            // Нашли null после non-null значения
            // Возвращаемся к null и заменяем его интерполированным значением
            iterator.previous(); // Переходим к null
            iterator.set((prev + getNextNonNull(iterator)) / 2);
            iterator.next(); // Продолжаем
        }
        
        prev = current;
    }
}

public static <T extends Comparable<T>> void insertSorted(List<T> sortedList, T newElement) {
    ListIterator<T> iterator = sortedList.listIterator();
    
    while (iterator.hasNext()) {
        if (newElement.compareTo(iterator.next()) < 0) {
            // Нашли позицию для вставки
            iterator.previous(); // Возвращаемся к элементу, который больше нового
            iterator.add(newElement);
            return;
        }
    }
    
    // Новый элемент больше всех существующих
    iterator.add(newElement);
}

public class AdvancedListProcessing {
    
    public static <T> void bidirectionalTransform(List<T> list, 
                                                  Function<T, T> forwardTransform,
                                                  Function<T, T> backwardTransform) {
        ListIterator<T> iterator = list.listIterator();
        
        // Фаза 1: Прямой обход с трансформацией
        while (iterator.hasNext()) {
            T original = iterator.next();
            T transformed = forwardTransform.apply(original);
            iterator.set(transformed);
        }
        
        // Фаза 2: Обратный обход с дополнительной трансформацией
        while (iterator.hasPrevious()) {
            T current = iterator.previous();
            T doublyTransformed = backwardTransform.apply(current);
            
            // Условная вставка нового элемента
            if (shouldInsertAfter(current)) {
                iterator.next(); // Переходим к следующей позиции для вставки
                iterator.add(generateNewElement(current));
                iterator.previous(); // Возвращаемся к текущему элементу
            }
            
            iterator.set(doublyTransformed);
        }
    }
    
    public static <T> List<T> mergeAdjacentDuplicates(List<T> list) {
        if (list.size() < 2) {
            return new ArrayList<>(list);
        }
        
        ListIterator<T> iterator = list.listIterator();
        List<T> result = new ArrayList<>();
        
        T current = iterator.next();
        result.add(current);
        
        while (iterator.hasNext()) {
            T next = iterator.next();
            
            if (!current.equals(next)) {
                // Разные элементы - добавляем в результат
                result.add(next);
                current = next;
            } else {
                // Дубликат - пропускаем
                // При необходимости можно выполнить merge операцию
                mergeLastTwo(result);
            }
        }
        
        return result;
    }
    
    public static <T> void processWithLookaheadAndLookbehind(List<T> list,

                                                             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;
    }
}

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()
            }
        }
    }
}

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;
            }
        }
    }
}

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

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

// Неэффективно:
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 теперь перед ним
    }
}

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

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

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