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

import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import java.util.Objects;

//Антипаттерн: field injection
@Service
public class BadService {
    
    @Autowired
    private UserRepository userRepository; // не final, можно забыть проинициализировать
    
    @Autowired
    private EmailService emailService; // скрытая зависимость
    
    public void registerUser(User user) {
        // может быть NullPointerException, если забыли протестировать
        userRepository.save(user);
        emailService.sendWelcome(user);
    }
    
    // невозможно создать объект в тесте без Spring
}

//Правильно: constructor injection
@Service
public class GoodService {
    
    private final UserRepository userRepository;
    private final EmailService emailService;
    private final AuditService auditService;
    
    // С одним конструктором @Autowired не нужен (Spring 4.3+)
    public GoodService(UserRepository userRepository, 
                      EmailService emailService,
                      @Lazy AuditService auditService) {
        this.userRepository = Objects.requireNonNull(userRepository, 
            "UserRepository must not be null");
        this.emailService = Objects.requireNonNull(emailService);
        this.auditService = auditService; // @Lazy — прокси будет создан при первом вызове
    }
    
    public void registerUser(User user) {
        userRepository.save(user);
        emailService.sendWelcome(user);
        auditService.log("User registered: " + user.getId());
    }
}

// Для циклических зависимостей — @Lazy
@Service
class A {
    private final B b;
    
    public A(@Lazy B b) { // B создастся лениво
        this.b = b;
    }
}

@Service
class B {
    private final A a;
    
    public B(A a) {
        this.a = a;
    }
}

import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan
public class Task110326 {
    public static void main(String[] args) {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Task110326.class)) {
            UserService110326 service = context.getBean(UserService110326.class);
            System.out.println(service.getUser());
        }
    }
}

@Component
class UserService110326 {
    private UserRepository110326 userRepository;

    @Autowired
    public UserService110326(UserRepository110326 userRepository) {
        this.userRepository = userRepository;
    }

    public String getUser() {
        return userRepository.findUser();
    }
}

@Component
class UserRepository110326 {
    private DatabaseService110326 databaseService;

    @Autowired
    public UserRepository110326(DatabaseService110326 databaseService) {
        this.databaseService = databaseService;
    }

    public String findUser() {
        return "User from " + databaseService.getDataSource();
    }
}

@Component
class DatabaseService110326 {
    public String getDataSource() {
        return "MainDB";
    }
}

List<Book> library = new ArrayList<>(fetchBooks());
Stream<Book> stream = library.stream();  // Поток создан, но не активирован

// Позже, до терминальной операции:
library.add(new Book("New", "Author", 2024));  // Модификация источника!

// Теперь терминальная операция:
List<Book> result = stream.collect(toList());  // ConcurrentModificationException?

// Катастрофа: модификация источника изнутри потока
library.stream()
    .filter(b -> b.year() < 1950)
    .forEach(library::remove);  // ConcurrentModificationException гарантирован

// Правильно: фильтрация через collect, не removeIf в потоке
List<Book> modernBooks = library.stream()
    .filter(b -> b.year() >= 1950)
    .collect(toList());

// Или без потока, если модификация исходной нужна:
library.removeIf(b -> b.year() < 1950);  // Метод коллекции, не Stream API

public class MutableBook {
    private String title;
    private int readCount;  // Мутабельное поле!
    
    public void incrementRead() { readCount++; }
}

// Антипаттерн: мутация внутри потока
List<MutableBook> books = fetchBooks();
books.stream()
    .filter(b -> b.getTitle().startsWith("A"))
    .forEach(MutableBook::incrementRead);  //Модифицируем исходные объекты!

// Теперь исходный список books изменён — побочный эффект

public record Book(String title, int readCount) {
    public Book withIncrementedRead() {
        return new Book(title, readCount + 1);  //Новый экземпляр
    }
}

// Правильно: создание новых объектов
List<Book> updatedBooks = books.stream()
    .filter(b -> b.title().startsWith("A"))
    .map(Book::withIncrementedRead)
    .collect(toList());

// Исходный список books неизменён

AtomicInteger processedCount = new AtomicInteger(0);

List<Result> results = items.parallelStream()
    .map(this::heavyProcessing)
    .peek(r -> processedCount.incrementAndGet())  // Контролируемый эффект
    .collect(toList());

System.out.println("Обработано: " + processedCount.get());

// Лучше: явная агрегация результата
class ProcessingResult {
    final List<Result> results;
    final int count;
    ProcessingResult(List<Result> results, int count) {
        this.results = results;
        this.count = count;
    }
}

ProcessingResult finalResult = items.parallelStream()
    .collect(() -> new ProcessingResult(new ArrayList<>(), 0),
        (acc, item) -> {
            acc.results.add(process(item));
            acc.count++;
        },
        (left, right) -> {
            left.results.addAll(right.results);
            left.count += right.count;
        });

orders.stream()
    .filter(o -> o.amount().compareTo(THRESHOLD) > 0)
    .peek(o -> auditLog.record("Крупный заказ", o.id()))  // Побочный эффект
    .map(this::processLargeOrder)
    .collect(toList());

List<ProcessedOrder> processed = orders.stream()
    .filter(o -> o.amount().compareTo(THRESHOLD) > 0)
    .map(o -> {
        auditLog.record("Крупный заказ", o.id());  // Явный эффект в map
        return processLargeOrder(o);
    })
    .collect(toList());

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

public class Task120326 {
    public static void main(String[] args) {
        List<Person120326> people = new ArrayList<>(Arrays.asList(
            new Person120326("Alice", 25),
            new Person120326("Bob", 30),
            new Person120326("Charlie", 20)
        ));
        
        List<String> names = people.stream()
            .map(p -> p.name)
            .sorted((a, b) -> {
                people.get(0).age = 999;
                return a.compareTo(b);
            })
            .collect(Collectors.toList());
        
        System.out.println(people);
        System.out.println(names);
    }
    
    static class Person120326 {
        String name;
        int age;
        
        Person120326(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public String toString() {
            return name + ":" + age;
        }
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {
    
    @Autowired
    private AsyncService selfProxy; // self-injection
    
    @Async
    public CompletableFuture<String> asyncMethod() {
        System.out.println("Асинхронный вызов в потоке: " + Thread.currentThread().getName());
        return CompletableFuture.completedFuture("Результат");
    }
    
    //Проблема: прямой вызов
    public void badCall() {
        System.out.println("Прямой вызов");
        asyncMethod(); // this.asyncMethod() — асинхронности НЕТ!
    }
    
    //Решение: вызов через self-proxy
    public void goodCall() {
        System.out.println("Вызов через self-proxy");
        selfProxy.asyncMethod(); // через прокси — асинхронно
    }
}

// Альтернатива: отдельный компонент
@Service
class AsyncWorker {
    @Async
    public CompletableFuture<String> doWork() {
        return CompletableFuture.completedFuture("Работа выполнена");
    }
}

@Service
class CallerService {
    @Autowired
    private AsyncWorker worker;
    
    public void call() {
        worker.doWork(); // асинхронно через прокси
    }
}

@SpringBootApplication
@EnableAsync
public class Task130326 implements CommandLineRunner {

    @Autowired
    private AsyncService130326 service;

    public static void main(String[] args) {
        SpringApplication.run(Task130326.class, args);
    }

    @Override
    public void run(String... args) {
        service.directCall();
        service.proxyCall();
    }
}

@Component
class AsyncService130326 {
    @Lazy
    @Autowired
    private AsyncService130326 self;

    @Async
    public void asyncMethod() {
        System.out.println("asyncMethod: " + Thread.currentThread().getName());
    }

    public void directCall() {
        System.out.println("directCall: " + Thread.currentThread().getName());
        asyncMethod();
    }

    public void proxyCall() {
        System.out.println("proxyCall: " + Thread.currentThread().getName());
        self.asyncMethod();
    }
}