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

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.support.TransactionSynchronizationManager;

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private UserService selfProxy; // Self-injection для вызова из того же класса
    
    //Антипаттерн: @Transactional на private методе
    @Transactional
    private void badPrivateMethod(User user) {
        // Транзакции НЕ БУДЕТ! Метод не переопределяется прокси
        userRepository.save(user);
        if (user.getEmail() == null) {
            throw new RuntimeException("Ошибка — отката не будет!");
        }
    }
    
    //Правильно: public метод
    @Transactional
    public void goodPublicMethod(User user) {
        userRepository.save(user);
        if (user.getEmail() == null) {
            throw new RuntimeException("Ошибка — транзакция откатится");
        }
    }
    
    // Проблема внутреннего вызова
    public void callInternal() {
        User user = new User("John");
        //Транзакции не будет — вызов напрямую, не через прокси
        goodPublicMethod(user); // ФАКТИЧЕСКИ: this.goodPublicMethod()
    }
    
    //Решение: вызов через self-proxy
    public void callCorrectly() {
        User user = new User("John");
        selfProxy.goodPublicMethod(user); // Вызов через прокси — транзакция работает
    }
}

// Альтернативное решение: вынос логики в отдельный компонент
@Service
class InternalUserService {
    @Transactional
    public void doInTransaction(User user) {
        // транзакционная логика
    }
}

@Service
class MainUserService {
    @Autowired
    private InternalUserService internalService;
    
    public void call() {
        internalService.doInTransaction(new User("John")); // Транзакция работает
    }
}

@SpringBootApplication
public class TransactionalTricky implements CommandLineRunner {
    
    @Autowired
    private UserService userService;
    
    public static void main(String[] args) {
        SpringApplication.run(TransactionalTricky.class, args);
    }
    
    @Override
    public void run(String... args) {
        userService.saveUser();
        System.out.println(userService.getCounter());
    }
    
    @Service
    static class UserService {
        private int counter = 0;
        
        @Transactional
        public void saveUser() {
            privateIncrement();
        }
        
        @Transactional
        private void privateIncrement() {
            counter++;
        }
        
        public int getCounter() {
            return counter;
        }
    }
}

public class Book {
    private final String title;
    private final String author;
    private final int year;
    
    // Конструктор, геттеры
    // equals и hashCode НЕ переопределены!
}

// Две логически идентичные книги
Book book1 = new Book("1984", "George Orwell", 1949);
Book book2 = new Book("1984", "George Orwell", 1949);

// Создаём поток с дублированием
List<Book> library = Arrays.asList(book1, book1, book2, book2);

// Группировка по книге как ключу
Map<Book, Long> countByBook = library.stream()
    .collect(groupingBy(Function.identity(), counting()));

System.out.println(countByBook.size());  // Ожидаем 1, получаем...?

List<Book> uniqueBooks = library.stream()
    .distinct()
    .collect(toList());

Set<Book> bookSet = library.stream()
    .collect(toSet());

System.out.println(bookSet.size());  // Ожидаем 1, получаем 2

public class Author {
    private String name;  // Не final! Сеттер есть!
    private String country;
    
    // equals и hashCode по всем полям
    @Override public int hashCode() {
        return Objects.hash(name, country);
    }
}

// Группировка книг по автору
Map<Author, List<Book>> byAuthor = library.stream()
    .collect(groupingBy(Book::author));

// Позже в коде...
Author key = byAuthor.keySet().iterator().next();
key.setName("Modified Name");  // Мутация ключа!

// Попытка доступа
List<Book> books = byAuthor.get(key);  // null?!

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Book book = (Book) o;
    return year == book.year &&
           Objects.equals(title, book.title) &&
           Objects.equals(author, book.author);
}

@Override
public int hashCode() {
    return Objects.hash(title, author, year);
}

public record Book(String title, String author, int year) {}

// Автоматически: final поля, конструктор, геттеры, equals, hashCode, toString

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

public class Task100326 {
    public static void main(String[] args) {
        List<Item100326> items = Arrays.asList(
            new Item100326(1, "A"),
            new Item100326(1, "B"),
            new Item100326(2, "C"),
            new Item100326(2, "D")
        );
        
        Set<Item100326> set = new LinkedHashSet<>(items);
        
        Map<Integer, List<Item100326>> grouped = items.stream()
            .collect(Collectors.groupingBy(Item100326::getId));
        
        System.out.print(set.size() + " ");
        System.out.print(grouped.get(1).size() + " ");
        System.out.print(grouped.get(2).get(0).getName());
    }
    
    static class Item100326 {
        private int id;
        private String name;
        
        Item100326(int id, String name) {
            this.id = id;
            this.name = name;
        }
        
        public int getId() { return id; }
        public String getName() { return name; }
        
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Item100326 item = (Item100326) o;
            return id == item.id;
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(id);
        }
    }
}