// Для toList(): () -> new ArrayList<T>()
// Для toSet(): () -> new HashSet<T>()
// Для toMap(): () -> new HashMap<K, V>()

// Для toList(): (list, element) -> list.add(element)
// Для toMap(): (map, element) -> map.put(keyExtractor.apply(element), valueExtractor.apply(element))

// Для toList(): (left, right) -> { left.addAll(right); return left; }
// Для toSet(): (left, right) -> { left.addAll(right); return left; }

// collectingAndThen(toList(), Collections::unmodifiableList)
// finisher: list -> Collections.unmodifiableList(list)

public static Collector<String, ?, String> joiningWithLimit(int maxLength) {
    class StringBuilderWithFlag {
        StringBuilder builder = new StringBuilder();
        boolean truncated = false;
    }
    
    return Collector.of(
        StringBuilderWithFlag::new,                                    // supplier
        (container, str) -> {                                          // accumulator
            if (container.truncated) return;
            if (container.builder.length() + str.length() > maxLength) {
                container.builder.append("[truncated]");
                container.truncated = true;
            } else {
                if (container.builder.length() > 0) container.builder.append(", ");
                container.builder.append(str);
            }
        },
        (left, right) -> {                                             // combiner
            if (left.truncated) return left;
            if (right.truncated) {
                left.builder.append("[truncated]");
                left.truncated = true;
                return left;
            }
            if (left.builder.length() + right.builder.length() > maxLength) {
                left.builder.append(", ").append(right.builder).append("[truncated]");
                left.truncated = true;
            } else {
                if (left.builder.length() > 0) left.builder.append(", ");
                left.builder.append(right.builder);
            }
            return left;
        },
        container -> container.builder.toString(),                      // finisher
        Characteristics.UNORDERED                                       // порядок не важен
    );
}

// Использование
String summary = tags.stream()
    .collect(joiningWithLimit(100));

// Опасно: бросит исключение при повторяющемся авторе
Map<String, Book> bookByAuthor = books.stream()
    .collect(toMap(Book::author, book -> book));  // Crash на второй книге того же автора

// Сохраняем первую встреченную книгу автора
Map<String, Book> firstByAuthor = books.stream()
    .collect(toMap(
        Book::author,
        book -> book,
        (existing, replacement) -> existing  // Игнорируем повторы
    ));

// Сохраняем последнюю, обновляем
Map<String, Book> lastByAuthor = books.stream()
    .collect(toMap(
        Book::author,
        book -> book,
        (oldBook, newBook) -> newBook  // Перезаписываем
    ));

// Агрегируем: список всех книг автора
Map<String, List<Book>> allByAuthor = books.stream()
    .collect(toMap(
        Book::author,
        book -> new ArrayList<>(List.of(book)),  // Создаём список из одной книги
        (existingList, newList) -> {
            existingList.addAll(newList);         // Добавляем к существующему
            return existingList;
        }
    ));

// Опасно: NPE если book.getDescription() возвращает null
Map<String, String> descriptions = books.stream()
    .collect(toMap(Book::title, Book::description));  // Crash на null

// Фильтрация
Map<String, String> validDescriptions = books.stream()
    .filter(b -> b.description() != null)
    .collect(toMap(Book::title, Book::description));

// Обёртка в Optional (требует адаптации типа)
Map<String, Optional<String>> optionalDescriptions = books.stream()
    .collect(toMap(
        Book::title,
        b -> Optional.ofNullable(b.description())
    ));

// Заполнитель с последующей фильтрацией
String NULL_MARKER = "\u0000";
Map<String, String> markedDescriptions = books.stream()
    .collect(toMap(
        Book::title,
        b -> b.description() != null ? b.description() : NULL_MARKER
    ));
// При использовании: if (!value.equals(NULL_MARKER))

// Опасно: ключ — изменяемый объект
record MutableKey(String name) {
    public void setName(String name) { this.name = name; }  // Mutable!
}

Map<MutableKey, Book> map = books.stream()
    .collect(toMap(book -> new MutableKey(book.author()), book -> book));

// Последующая модификация ключа делает Map некорректным
map.keySet().iterator().next().setName("Changed");  // Неопределённое поведение

// Немодифицируемый список
List<Book> unmodifiable = books.stream()
    .collect(collectingAndThen(toList(), Collections::unmodifiableList));

// Строка из списка с префиксом и суффиксом
String joined = books.stream()
    .map(Book::title)
    .collect(collectingAndThen(
        joining(", "),
        str -> "Titles: " + str + "."
    ));

// Группировка только ненулевых описаний по жанру
Map<Genre, List<String>> descriptionsByGenre = books.stream()
    .collect(groupingBy(
        Book::genre,
        filtering(
            b -> b.description() != null,
            mapping(Book::description, toList())
        )
    ));

// Средняя цена по авторам (автор -> средняя цена его книг)
Map<String, Double> avgPriceByAuthor = books.stream()
    .collect(groupingBy(
        Book::author,
        mapping(Book::price, averagingDouble(BigDecimal::doubleValue))
    ));

import java.util.*;
import java.util.stream.*;

public class Task020326 {
    public static void main(String[] args) {
        List<String> items = Arrays.asList("apple", "banana", "apricot", "cherry");
        
        Map<Character, String> map = items.stream()
            .collect(Collectors.toMap(
                s -> s.charAt(0),
                    String::toUpperCase,
                (v1, v2) -> v1 + "&" + v2
            ));
        
        System.out.println(map.get('a'));
    }
}

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

public class RandomExample {
    
    private static final Random SHARED_RANDOM = new Random();
    
    //Антипаттерн: общий Random в многопоточке
    public static class BadTask implements Callable<Integer> {
        @Override
        public Integer call() {
            // Конкуренция за общий Random
            return SHARED_RANDOM.nextInt(100);
        }
    }
    
    //Правильно: ThreadLocalRandom
    public static class GoodTask implements Callable<Integer> {
        @Override
        public Integer call() {
            // Каждый поток использует свой генератор
            return ThreadLocalRandom.current().nextInt(100);
        }
    }
    
    //Антипаттерн: создание Random в каждом потоке
    public static class WastefulTask implements Callable<Integer> {
        @Override
        public Integer call() {
            // Новый объект при каждом вызове — лишняя аллокация
            return new Random().nextInt(100);
        }
    }
    
    // Демонстрация производительности
    public static void main(String[] args) throws Exception {
        int threads = 10;
        int tasksPerThread = 100000;
        
        ExecutorService executor = Executors.newFixedThreadPool(threads);
        
        // Плохой вариант
        long start = System.nanoTime();
        List<Callable<Integer>> badTasks = Collections.nCopies(threads * tasksPerThread, new BadTask());
        executor.invokeAll(badTasks);
        long end = System.nanoTime();
        System.out.println("Shared Random: " + TimeUnit.NANOSECONDS.toMillis(end - start) + " ms");
        
        // Хороший вариант
        start = System.nanoTime();
        List<Callable<Integer>> goodTasks = Collections.nCopies(threads * tasksPerThread, new GoodTask());
        executor.invokeAll(goodTasks);
        end = System.nanoTime();
        System.out.println("ThreadLocalRandom: " + TimeUnit.NANOSECONDS.toMillis(end - start) + " ms");
        
        executor.shutdown();
    }
}

import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Task030326 {
    public static void main(String[] args) throws InterruptedException {
        Random random = new Random();
        int[] results = new int[1000];

        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            final int index = i;
            executor.submit(() -> {
                results[index] = random.nextInt(100);
            });
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);

        long nonZeroCount = Arrays.stream(results).filter(x -> x != 0).count();
        System.out.println(nonZeroCount);
    }
}

Map<String, List<Book>> booksByAuthor = library.stream()
    .collect(groupingBy(Book::author));

Map<String, Long> bookCountByAuthor = library.stream()
    .collect(groupingBy(Book::author, counting()));

Map<String, List<String>> titlesByAuthor = library.stream()
    .collect(groupingBy(
        Book::author,
        mapping(Book::title, toList())
    ));

Map<String, Optional<Book>> newestByAuthor = library.stream()
    .collect(groupingBy(
        Book::author,
        maxBy(comparing(Book::year))
    ));

// Группировка сначала по жанру, затем по автору
Map<Genre, Map<String, List<Book>>> byGenreThenAuthor = library.stream()
    .collect(groupingBy(
        Book::genre,
        groupingBy(Book::author)
    ));

record GenreAuthor(Genre genre, String author) {}

Map<GenreAuthor, List<Book>> byCompositeKey = library.stream()
    .collect(groupingBy(
        b -> new GenreAuthor(b.genre(), b.author())
    ));

// Для каждого автора: множество жанров, средняя цена, самая старая книга
record AuthorStats(Set<Genre> genres, double avgPrice, Book oldest) {}

Map<String, AuthorStats> statsByAuthor = library.stream()
    .collect(groupingBy(
        Book::author,
        collectingAndThen(
            teeing(
                teeing(
                    mapping(Book::genre, toSet()),           // Набор жанров
                    averagingDouble(Book::price),            // Средняя цена
                    Pair::new                                // Временная пара
                ),
                minBy(comparing(Book::year)),                // Самая старая книга
                (pair, oldestOpt) -> new AuthorStats(
                    pair.first(),
                    pair.second(),
                    oldestOpt.orElseThrow()
                )
            ),
            Function.identity()
        )
    ));

record PriceStats(double min, double max, double average) {}

PriceStats stats = products.stream()
    .collect(teeing(
        minBy(comparing(Product::price)),
        teeing(
            maxBy(comparing(Product::price)),
            averagingDouble(Product::price),
            (maxOpt, avg) -> new Pair<>(maxOpt, avg)
        ),
        (minOpt, pair) -> new PriceStats(
            minOpt.map(Product::price).orElse(0.0),
            pair.first().map(Product::price).orElse(0.0),
            pair.second()
        )
    ));

Map<Boolean, List<Book>> partitioned = library.stream()
    .collect(partitioningBy(b -> b.year() >= 2000));

List<Book> modernBooks = partitioned.get(true);   // 2000 и позже
List<Book> classicBooks = partitioned.get(false); // До 2000

Map<Boolean, Long> counts = library.stream()
    .collect(partitioningBy(
        b -> b.year() >= 2000,
        counting()  // downstream коллектор поддерживается
    ));

long modernCount = counts.get(true);
long classicCount = counts.get(false);  // Никогда null, минимум 0