import java.util.*;

public class Task101225 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        Iterator<Integer> it = list.iterator();
        
        System.out.print(it.next() + " ");
        System.out.print(it.next() + " ");
        
        it.remove();
        
        System.out.print(it.next() + " ");
        list.add(6);
        
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
}

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