// Оптимально для 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;
}

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class Task161225 {
    public static void main(String[] args) {
        List<Integer> failFast = new ArrayList<>(Arrays.asList(1, 2, 3));
        List<Integer> failSafe = new CopyOnWriteArrayList<>(Arrays.asList(1, 2, 3));
        
        try {
            for (int num : failFast) {
                System.out.print(num + " ");
                if (num == 2) failFast.add(4);
            }
        } catch (Exception e) {
            System.out.print("FFex ");
        }
        
        try {
            for (int num : failSafe) {
                System.out.print(num + " ");
                if (num == 2) failSafe.add(4);
            }
        } catch (Exception e) {
            System.out.print("FSex ");
        }
        
        System.out.print(failFast.size() + " ");
        System.out.print(failSafe.size());
    }
}