public class ConcurrentModificationExample {
    
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        
        //Антипаттерн: удаление в for-each
        try {
            for (String item : list) {
                if (item.equals("b")) {
                    list.remove(item); //ConcurrentModificationException!
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("Ошибка: " + e);
        }
        
        //Явный Iterator.remove()
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("b")) {
                iterator.remove(); // Безопасно
            }
        }
        System.out.println("После iterator.remove(): " + list);
        
        //removeIf()
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        list.removeIf(item -> item.equals("b")); // Самый лаконичный способ
        System.out.println("После removeIf(): " + list);
        
        //Сбор элементов для удаления
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        List<String> toRemove = new ArrayList<>();
        for (String item : list) {
            if (item.equals("b")) {
                toRemove.add(item); //Отмечаем на удаление
            }
        }
        list.removeAll(toRemove); //Удаляем после итерации
        System.out.println("После removeAll(): " + list);
    }
}

import java.util.*;

public class Task190326 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E"));
        
        for (String s : list) {
            if (s.equals("C")) {
                list.remove(s);
            }
            System.out.print(s + " ");
        }
    }
}

// ArrayList: O(1) разделение, равномерная нагрузка
List<Book> books = new ArrayList<>(100000);
books.parallelStream()  // Эффективен
    .map(this::expensiveAnalysis)
    .collect(toList());

// LinkedList: разделение O(n), часто деградирует к последовательному
LinkedList<Book> linkedBooks = new LinkedList<>();
linkedBooks.parallelStream()  // Нет выигрыша, возможен проигрыш
    .map(this::expensiveAnalysis)
    .collect(toList());

// Stream.iterate: не делится, parallel бесполезен
Stream.iterate(0, n -> n + 1)
    .parallel()  // Игнорируется
    .limit(1000)
    .map(this::expensiveComputation)
    .collect(toList());

// Слишком дёшево: параллелизм замедлит
List<Integer> doubled = numbers.parallelStream()
    .map(n -> n * 2)  // Одна инструкция процессора
    .collect(toList());

// Достаточно дорого: параллелизм ускорит
List<Result> analyzed = documents.parallelStream()
    .map(doc -> nlpPipeline.analyze(doc))  // 50-100 мс на документ
    .collect(toList());

// Антипаттерн: общий счётчик
AtomicInteger counter = new AtomicInteger(0);

List<Result> results = data.parallelStream()
    .map(d -> {
        counter.incrementAndGet();  // Потокобезопасен, но не бесплатен
        return process(d);
    })
    .collect(toList());

// Катастрофа: ArrayList не потокобезопасен
List<Result> results = data.parallelStream()
    .map(this::process)
    .collect(ArrayList::new, List::add, List::addAll);  // Race condition!

// Опасность: изменяемый ключ после группировки
Map<MutableAuthor, List<Book>> byAuthor = books.parallelStream()
    .collect(groupingBy(MutableAuthor::new));

// Позже в другом потоке...
byAuthor.keySet().iterator().next().setName("New");  // Непредсказуемое поведение

// Барьер: локальная сортировка + глобальное слияние
List<Book> sorted = books.parallelStream()
    .sorted(comparing(Book::year))  // Накладные расходы на merge
    .collect(toList());

// Плохо: упорядоченный источник + findFirst в parallel
Optional<Book> first = books.parallelStream()
    .filter(b -> b.year() > 2000)
    .findFirst();  // Требует проверки всех предшествующих сегментов

// Лучше: findAny для неупорядоченных задач
Optional<Book> any = books.parallelStream()
    .filter(b -> b.year() > 2000)
    .findAny();  // Первый найденный в любом сегменте

// JMH-бенчмарк для сравнения
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class StreamBenchmark {
    
    @State(Scope.Thread)
    public static class Data {
        List<Book> books = generateBooks(100000);
    }
    
    @Benchmark
    public List<Result> sequential(Data d) {
        return d.books.stream()
            .map(this::expensiveTransform)
            .collect(toList());
    }
    
    @Benchmark
    public List<Result> parallel(Data d) {
        return d.books.parallelStream()
            .map(this::expensiveTransform)
            .collect(toList());
    }
}

import java.util.*;

public class Task200326 {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        List<Integer> list2 = new LinkedList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        
        long count1 = list1.parallelStream()
            .map(x -> {
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                return x * 2;
            })
            .count();
            
        long count2 = list2.parallelStream()
            .map(x -> {
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                return x * 2;
            })
            .count();
            
        System.out.println(count1 == count2);
        System.out.println(list1.parallelStream().isParallel());
        System.out.println(list2.parallelStream().isParallel());
    }
}