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

// Пример внутренней реализации
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}.

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

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

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

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

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

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

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<>();
        // геттеры и сеттеры
    }
}

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

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

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

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

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;
        
        // Геттеры и сеттеры
    }
}

@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;
        
        // Геттеры и сеттеры
    }
}

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

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

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

public class Task151225 {
    public static void main(String[] args) {
        Boolean b1 = true;
        Boolean b2 = new Boolean(true);
        boolean b3 = true;
        Boolean b4 = Boolean.valueOf(true);
        
        System.out.println(b1 == b2);
        System.out.println(b1 == b3);
        System.out.println(b2 == b4);
        System.out.println(b3 == b4);
    }
}

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

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

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

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

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

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

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

// Псевдокод байт-кода
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

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 (инициализация; условие; инкремент) {
    // Тело цикла
}

// Псевдокод байт-кода
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);
}

// 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 (эффективно)
for (String item : linkedList) {
    process(item);
}

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

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

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

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

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

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

// Пример из 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; // Синхронизация после успешного удаления
    }
}

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

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

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

Использование 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

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

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

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

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

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

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

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

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

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

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; // Безопасное чтение
    }
}

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

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

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

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

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

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

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

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

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

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