public class Book {
    private final String title;
    private final String author;
    
    public Book(String title, String author) {
        this.title = Objects.requireNonNull(title, "title не может быть null");
        this.author = Objects.requireNonNull(author, "author не может быть null");
    }
    
    public String getTitle() { return title; }
    public String getAuthor() { return author; }
    
    @Override
    public String toString() {
        return "Book[title=" + title + ", author=" + author + "]";
    }
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Book)) return false;
    Book book = (Book) o;
    return title.equals(book.title);  // Только title! Автор игнорируется.
}

public void demonstrateDistinctProblem() {
    List<Book> books = Arrays.asList(
        new Book("Война и мир", "Толстой"),
        new Book("Война и мир", "Достоевский"),  // Другой автор!
        new Book("1984", "Оруэлл")
    );
    
    List<Book> distinct = books.stream()
        .distinct()
        .collect(Collectors.toList());
    
    System.out.println("Исходный список: " + books.size() + " книг");
    System.out.println("После distinct: " + distinct.size() + " книг");
    System.out.println("Уникальные книги: " + distinct);
}

Исходный список: 3 книг
После distinct: 2 книг
Уникальные книги: [Book[title=Война и мир, author=Толстой], Book[title=1984, author=Оруэлл]]

public void demonstrateToMapProblem() {
    List<Book> inventory = Arrays.asList(
        new Book("Война и мир", "Толстой"),
        new Book("Война и мир", "Достоевский")
    );
    
    Map<Book, Integer> stock = inventory.stream()
        .collect(Collectors.toMap(
            Function.identity(),
            b -> 10,  // количество на складе
            (a, b) -> a + b  // слияние при коллизии
        ));
    
    System.out.println("Map: " + stock);
    
    // Попытка получить значение по «эквивалентной» книге
    Book lookup = new Book("Война и мир", "Толстой");
    System.out.println("Поиск " + lookup + ": " + stock.get(lookup));
    
    Book lookupWrongAuthor = new Book("Война и мир", "Гоголь");
    System.out.println("Поиск " + lookupWrongAuthor + ": " + stock.get(lookupWrongAuthor));
}

public void demonstrateGroupingProblem() {
    List<Book> books = Arrays.asList(
        new Book("Война и мир", "Толстой"),
        new Book("Война и мир", "Достоевский"),
        new Book("Война и мир", "Тургенев")
    );
    
    Map<Book, List<Book>> byBook = books.stream()
        .collect(Collectors.groupingBy(Function.identity()));
    
    System.out.println("Групп: " + byBook.size());
    byBook.forEach((k, v) -> System.out.println(k + " -> " + v.size()));
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Book)) return false;
    Book book = (Book) o;
    return title.equals(book.title) && 
           author.equals(book.author);  // Теперь оба поля!
}

@Override
public int hashCode() {
    return Objects.hash(title, author);  // Консистентно с equals
}

public void demonstrateFixed() {
    List<Book> books = Arrays.asList(
        new Book("Война и мир", "Толстой"),
        new Book("Война и мир", "Достоевский"),
        new Book("1984", "Оруэлл")
    );
    
    // distinct() — теперь 3 уникальные книги
    System.out.println("distinct: " + books.stream().distinct().count());
    
    // toMap — теперь 3 записи
    Map<Book, Integer> stock = books.stream()
        .collect(Collectors.toMap(
            Function.identity(),
            b -> 10,
            Integer::sum
        ));
    System.out.println("Map size: " + stock.size());
    
    // Поиск работает
    Book lookup = new Book("Война и мир", "Толстой");
    System.out.println("Найдено: " + stock.get(lookup));
}

private final String isbn;  // уникальный, неизменяемый

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Book)) return false;
    return isbn.equals(((Book) o).isbn);
}

@Override
public int hashCode() {
    return isbn.hashCode();
}

// Нет equals/hashCode — используем Object

public List<Book> findByTitle(String title) {
    return books.stream()
        .filter(b -> b.getTitle().equals(title))
        .collect(Collectors.toList());
}

private int hashCode;  // 0 = не вычислено

@Override
public int hashCode() {
    int result = hashCode;
    if (result == 0) {
        result = Objects.hash(title, author);
        hashCode = result;
    }
    return result;
}

public class Task160326 {
    public static void main(String[] args) {
        String s1 = "  hello  ".trim();
        String s2 = "  hello  ".strip();
        String s3 = "\u2000hello\u2000".trim();
        String s4 = "\u2000hello\u2000".strip();
        
        System.out.println(s1.equals(s2));
        System.out.println(s3.length());
        System.out.println(s4.length());
    }
}

@Entity
public class Order {
    @Id private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private User user; // ленивая загрузка
    
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
    private List<Item> items;
    // геттеры/сеттеры
}

@Service
public class OrderService {
    
    @PersistenceContext
    private EntityManager em;
    
    //Антипаттерн: сессия закрыта при доступе к ленивым полям
    public Order badFind(Long id) {
        Order order = em.find(Order.class, id);
        // Транзакция закончилась, сессия закрыта
        order.getUser().getName(); // LazyInitializationException!
        return order;
    }
    
    //Решение 1: @Transactional на уровне сервиса
    @Transactional
    public Order goodFindTransactional(Long id) {
        Order order = em.find(Order.class, id);
        order.getUser().getName(); // Ок, сессия открыта
        return order;
    }
    
    //Решение 2: JOIN FETCH в запросе
    @Transactional(readOnly = true)
    public Order findWithJoinFetch(Long id) {
        return em.createQuery(
            "SELECT o FROM Order o JOIN FETCH o.user WHERE o.id = :id", Order.class)
            .setParameter("id", id)
            .getSingleResult(); // user уже загружен
    }
    
    //Решение 3: EntityGraph
    @Transactional(readOnly = true)
    public Order findWithEntityGraph(Long id) {
        EntityGraph<?> graph = em.getEntityGraph("Order.withUserAndItems");
        return em.find(Order.class, id, 
            Collections.singletonMap("javax.persistence.fetchgraph", graph));
    }
}

// DTO-подход — лучшая практика
@Data
class OrderDTO {
    private Long id;
    private String userName; // только нужные поля, без прокси
}

@Service
class OrderDTOService {
    @PersistenceContext
    private EntityManager em;
    
    public OrderDTO findDTO(Long id) {
        return em.createQuery(
            "SELECT NEW com.example.OrderDTO(o.id, u.name) " +
            "FROM Order o JOIN o.user u WHERE o.id = :id", OrderDTO.class)
            .setParameter("id", id)
            .getSingleResult(); // Никаких прокси, только данные
    }
}

import java.util.*;

public class Task170326 {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add(null);
        list1.add("text");
        list1.remove(1);

        List<String> list2 = new ArrayList<>();
        list2.add("text");
        list2.remove(0);

        System.out.println(list1.isEmpty());
        System.out.println(list2.isEmpty());
        System.out.println(list1.size() == 0);
        System.out.println(list2.size() == 0);
    }
}

public interface Spliterator<T> {
    Spliterator<T> trySplit();  // Возвращает новый Spliterator для части данных или null
    void forEachRemaining(Consumer<? super T> action);
    boolean tryAdvance(Consumer<? super T> action);
    long estimateSize();
    int characteristics();
}

List<Result> results = urls.parallelStream()
    .map(url -> {
        try {
            return httpClient.fetch(url);  // Блокирующий HTTP-запрос, 500мс
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    })
    .collect(toList());

// Имитация тяжёлой работы
IntStream.range(0, 1000).parallel()
    .map(i -> {
        try { Thread.sleep(100); } catch (InterruptedException e) { }
        return i * 2;
    })
    .collect(toList());

ExecutorService ioPool = Executors.newFixedThreadPool(50);  // Много потоков, не боится блокировок

List<CompletableFuture<Result>> futures = urls.stream()
    .map(url -> CompletableFuture.supplyAsync(() -> fetch(url), ioPool))
    .collect(toList());

List<Result> results = futures.stream()
    .map(CompletableFuture::join)
    .collect(toList());

ioPool.shutdown();
Virtual Threads (Java 21+):
java
Copy
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    List<StructuredTaskScope.Subtask<Result>> subtasks = urls.stream()
        .map(url -> scope.fork(() -> fetch(url)))
        .collect(toList());
    
    scope.join().throwIfFailed();
    
    return subtasks.stream()
        .map(StructuredTaskScope.Subtask::get)
        .collect(toList());
}

// При запуске JVM
-Djava.util.concurrent.ForkJoinPool.common.parallelism=16

// Или программно, но только до первого использования пула
System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "16");

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class Task180326 {
    public static void main(String[] args) {
        ForkJoinPool pool = ForkJoinPool.commonPool();
        int result = pool.invoke(new Task(10));
        System.out.println(result);
    }
    
    static class Task extends RecursiveTask<Integer> {
        int n;
        Task(int n) { this.n = n; }
        
        @Override
        protected Integer compute() {
            if (n <= 1) return n;
            
            Task t1 = new Task(n - 1);
            Task t2 = new Task(n - 2);
            
            t1.fork();
            return t2.compute() + t1.join();
        }
    }
}