Stream<Book> classics = library.stream()
    .filter(book -> book.year() < 1980);

// Антипаттерн: предикат с побочным эффектом
AtomicInteger counter = new AtomicInteger(0);
Stream<Book> everyThird = library.stream()
    .filter(b -> counter.incrementAndGet() % 3 == 0);  // Недетерминировано при parallel()

Stream<String> titles = library.stream()
    .map(Book::title);

Stream<Integer> lengths = titles.map(String::length);

// Цепочка преобразований: Book -> String -> Integer -> String
String summary = book.stream()
    .map(Book::author)           // Book -> String
    .map(String::toUpperCase)    // String -> String
    .map(author -> author.substring(0, 3))  // String -> String
    .map(prefix -> "Author: " + prefix)     // String -> String
    .findFirst()
    .orElse("Unknown");

List<Order> orders = fetchOrders();

// Императивный подход: вложенные циклы, временная коллекция
List<OrderItem> allItems = new ArrayList<>();
for (Order order : orders) {
    for (OrderItem item : order.getItems()) {
        allItems.add(item);
    }
}

// Декларативный подход: flatMap
Stream<OrderItem> itemStream = orders.stream()
    .flatMap(order -> order.getItems().stream());

// Фильтрация через flatMap: ноль или один элемент
Stream<Book> validBooks = rawData.stream()
    .flatMap(data -> {
        try {
            Book book = parseBook(data);  // Может бросить исключение
            return Stream.of(book);         // Один элемент при успехе
        } catch (ParseException e) {
            return Stream.empty();          // Ноль элементов при ошибке
        }
    });

// Антипаттерн: глубокая вложенность flatMap
Stream<String> deepStream = orders.stream()
    .flatMap(order -> order.getShipments().stream()
        .flatMap(shipment -> shipment.getPackages().stream()
            .flatMap(pkg -> pkg.getItems().stream()
                .flatMap(item -> item.getTags().stream()))));

// Лучше: именованные методы с ясной семантикой
Stream<String> tags = orders.stream()
    .flatMap(this::extractShipments)
    .flatMap(this::extractPackages)
    .flatMap(this::extractItems)
    .flatMap(this::extractTags);

private Stream<Shipment> extractShipments(Order order) {
    return order.getShipments().stream();
}
// ... и так далее

// mapMulti: более эффективен, чем flatMap, для множественных элементов
Stream<String> tags = orders.stream()
    .<String>mapMulti((order, consumer) -> {
        for (Shipment s : order.getShipments()) {
            for (Package p : s.getPackages()) {
                for (Item i : p.getItems()) {
                    for (String tag : i.getTags()) {
                        consumer.accept(tag);  // Прямая передача без создания Stream
                    }
                }
            }
        }
    });

// "Найти все уникальные теги из активных заказов, отсортированные по алфавиту"
List<String> sortedUniqueTags = orders.stream()
    .filter(Order::isActive)           // которые активны
    .flatMap(o -> o.getTags().stream()) // извлечь все теги
    .distinct()                        // уникальные
    .sorted()                          // отсортированные
    .collect(toList());                // собрать в список

import java.util.stream.Stream;

public class Task200226 {
    public static void main(String[] args) {
        Stream.of(1, 2, 3, 4, 5)
            .filter(i -> {
                System.out.print(i + " ");
                return i % 2 == 0;
            })
            .map(i -> i * 10)
            .findFirst()
            .ifPresent(i -> System.out.print("result: " + i));
    }
}

import java.io.*;
import java.sql.*;

public class ExceptionHandling {
    
    //Антипаттерн
    public void bad(String path) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader(path));
        } catch (Exception e) { // Ловит IOException, NPE, OOM
            e.printStackTrace(); // Фатальные ошибки "проглочены"
        }
    }
    
    //Правильно
    public void good(String path) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            String line = reader.readLine();
        } catch (FileNotFoundException e) {
            System.err.println("Файл не найден: " + path);
            // Это восстановимая ситуация
        }
        // IOException пробрасывается выше
        // NPE, OOM не ловятся — пусть падают
    }
    
    //Multi-catch
    public void multi(String path) {
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path));
        } catch (FileNotFoundException | ClassNotFoundException e) {
            System.err.println("Ресурс не найден: " + e.getMessage());
        } catch (IOException e) {
            throw new RuntimeException("Ошибка ввода-вывода", e);
        }
    }
    
    //Единственный случай для Throwable
    public void thread(Runnable task) {
        new Thread(() -> {
            try {
                task.run();
            } catch (Throwable t) { // Только для логирования на верхнем уровне
                System.err.println("Критическая ошибка: " + t);
            }
        }).start();
    }
}

public class Task230226 {
    public static void main(String[] args) {
        try {
            throw new StackOverflowError();
        } catch (Error e) {
            System.out.println("Error caught");
        } catch (Exception e) {
            System.out.println("Exception caught");
        } catch (Throwable e) {
            System.out.println("Throwable caught");
        }
    }
}