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

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

public class Task040326 {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "apricot", "blueberry", "cherry");
        
        Map<Integer, Long> result = words.stream()
            .collect(Collectors.groupingBy(
                String::length,
                Collectors.counting()
            ));
            
        System.out.println(result);
    }
}

import java.util.*;

public class Advice050326 {
    
    private static final Map<String, Integer> SCORES = new HashMap<>();
    
    static {
        SCORES.put("Alice", 95);
        SCORES.put("Bob", 87);
        SCORES.put("Charlie", 92);
        SCORES.put("Diana", 98);
    }
    
    //Антипаттерн: итерация через keySet() + get()
    public static void badIteration() {
        System.out.println("Bad iteration (keySet + get):");
        for (String key : SCORES.keySet()) {
            // get() выполняет ПОЛНЫЙ поиск по мапе
            Integer value = SCORES.get(key);
            System.out.println(key + " = " + value);
        }
    }
    
    //Правильно: итерация через entrySet()
    public static void goodIteration() {
        System.out.println("Good iteration (entrySet):");
        for (Map.Entry<String, Integer> entry : SCORES.entrySet()) {
            // Данные уже извлечены, повторного поиска нет
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }
    }
    
    //Java 8+: forEach с лямбдой
    public static void lambdaIteration() {
        System.out.println("Lambda iteration (forEach):");
        SCORES.forEach((key, value) -> 
            System.out.println(key + " = " + value)
        );
    }
    
    //Модификация значений через entrySet
    public static void modifyValues() {
        Map<String, Integer> mutableMap = new HashMap<>(SCORES);
        
        // Увеличить баллы всем на 5
        for (Map.Entry<String, Integer> entry : mutableMap.entrySet()) {
            entry.setValue(entry.getValue() + 5); // Работает!
        }
        
        // Через keySet так не сделать
        System.out.println("Modified: " + mutableMap);
    }
    
    public static void main(String[] args) {
        badIteration();
        goodIteration();
        lambdaIteration();
        modifyValues();
    }
}

import java.util.*;

public class Task050326 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        
        Set<String> keys = map.keySet();
        for (String key : keys) {
            if (key.equals("b")) {
                map.remove("c");
            }
            System.out.print(key + "=" + map.get(key) + " ");
        }
    }
}

public class Book {
    private final String title;
    private final String author;
    private final int year;        // год издания
    private final int pages;       // количество страниц
    private final double price;    // цена
    private final List<String> genres;
    
    // конструктор, геттеры...
    
    public boolean hasGenre(String genre) {
        return genres.contains(genre);
    }
}

public Map<String, Book> getOldestBookByAuthor() {
    return books.stream()
        .collect(Collectors.toMap(
            Book::getAuthor,           // ключ — автор
            Function.identity(),       // значение — книга
            (existing, replacement) ->  // разрешение коллизии
                existing.getYear() < replacement.getYear() 
                    ? existing : replacement
        ));
}
Что происходит: при встрече второй книги того же автора сравниваем годы, оставляем старую.

public int getTotalPages() {
    return books.stream()
        .mapToInt(Book::getPages)
        .sum();
}
Что происходит: mapToInt создаёт примитивный поток, sum — терминальная редукция.

public OptionalDouble getAverageFantasyPrice() {
    return books.stream()
        .filter(Book::hasGenre, "Фантастика")
        .mapToDouble(Book::getPrice)
        .average();
}
Что происходит: фильтр оставляет только фантастику, average возвращает OptionalDouble для пустого результата.

public LibraryStatistics analyzeInOnePass() {
    return books.stream()
        .collect(Collectors.teeing(
            // Первый коллектор: автор → старая книга
            Collectors.toMap(
                Book::getAuthor,
                Function.identity(),
                (a, b) -> a.getYear() < b.getYear() ? a : b
            ),
            // Второй коллектор: teeing для страниц и фантастики
            Collectors.teeing(
                Collectors.summingInt(Book::getPages),
                Collectors.filtering(
                    b -> b.hasGenre("Фантастика"),
                    Collectors.averagingDouble(Book::getPrice)
                ),
                (totalPages, avgFantasyPrice) -> 
                    new IntermediateStats(totalPages, avgFantasyPrice)
            ),
            // Объединение результатов
            (oldestByAuthor, intermediate) -> new LibraryStatistics(
                oldestByAuthor,
                intermediate.totalPages,
                intermediate.avgFantasyPrice
            )
        ));
}

// Вспомогательные классы-контейнеры
private static class IntermediateStats {
    final int totalPages;
    final Double avgFantasyPrice;  // null если нет фантастики
    
    IntermediateStats(int totalPages, Double avgFantasyPrice) {
        this.totalPages = totalPages;
        this.avgFantasyPrice = avgFantasyPrice;
    }
}

public static class LibraryStatistics {
    public final Map<String, Book> oldestByAuthor;
    public final int totalPages;
    public final OptionalDouble avgFantasyPrice;
    
    // конструктор, преобразование Double → OptionalDouble...
}

public LibraryStatistics analyzeWithCustomCollector() {
    return books.stream()
        .collect(new LibraryStatsCollector());
}

private static class LibraryStatsCollector 
    implements Collector<Book, StatsAccumulator, LibraryStatistics> {
    
    @Override
    public Supplier<StatsAccumulator> supplier() {
        return StatsAccumulator::new;
    }
    
    @Override
    public BiConsumer<StatsAccumulator, Book> accumulator() {
        return (acc, book) -> {
            // Обновление Map авторов
            acc.oldestByAuthor.merge(
                book.getAuthor(),
                book,
                (a, b) -> a.getYear() < b.getYear() ? a : b
            );
            
            // Накопление страниц
            acc.totalPages += book.getPages();
            
            // Накопление для фантастики
            if (book.hasGenre("Фантастика")) {
                acc.fantasyCount++;
                acc.fantasyPriceSum += book.getPrice();
            }
        };
    }
    
    @Override
    public BinaryOperator<StatsAccumulator> combiner() {
        return (left, right) -> {
            // Слияние для параллельных потоков
            left.oldestByAuthor.putAll(right.oldestByAuthor); // с разрешением
            left.totalPages += right.totalPages;
            left.fantasyCount += right.fantasyCount;
            left.fantasyPriceSum += right.fantasyPriceSum;
            return left;
        };
    }
    
    @Override
    public Function<StatsAccumulator, LibraryStatistics> finisher() {
        return acc -> new LibraryStatistics(
            acc.oldestByAuthor,
            acc.totalPages,
            acc.fantasyCount == 0 
                ? OptionalDouble.empty()
                : OptionalDouble.of(acc.fantasyPriceSum / acc.fantasyCount)
        );
    }
    
    @Override
    public Set<Characteristics> characteristics() {
        return Collections.emptySet(); // не CONCURRENT из-за HashMap
    }
}

private static class StatsAccumulator {
    Map<String, Book> oldestByAuthor = new HashMap<>();
    int totalPages = 0;
    int fantasyCount = 0;
    double fantasyPriceSum = 0.0;
}

import java.util.concurrent.*;

public class Task060326 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.print("GO "));
        
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    latch.countDown();
                    latch.await();
                    barrier.await();
                } catch (Exception e) {}
            }).start();
        }
        
        latch.await();
        System.out.print("FINISH ");
    }
}