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

public class ConcurrentModificationExample {
    
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        
        //Антипаттерн: удаление в for-each
        try {
            for (String item : list) {
                if (item.equals("b")) {
                    list.remove(item); //ConcurrentModificationException!
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("Ошибка: " + e);
        }
        
        //Явный Iterator.remove()
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("b")) {
                iterator.remove(); // Безопасно
            }
        }
        System.out.println("После iterator.remove(): " + list);
        
        //removeIf()
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        list.removeIf(item -> item.equals("b")); // Самый лаконичный способ
        System.out.println("После removeIf(): " + list);
        
        //Сбор элементов для удаления
        list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
        List<String> toRemove = new ArrayList<>();
        for (String item : list) {
            if (item.equals("b")) {
                toRemove.add(item); //Отмечаем на удаление
            }
        }
        list.removeAll(toRemove); //Удаляем после итерации
        System.out.println("После removeAll(): " + list);
    }
}

import java.util.*;

public class Task190326 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E"));
        
        for (String s : list) {
            if (s.equals("C")) {
                list.remove(s);
            }
            System.out.print(s + " ");
        }
    }
}