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

// Антипаттерн: мутация внешнего списка из потока
List<String> names = new ArrayList<>();
users.stream()
    .filter(User::isActive)
    .forEach(u -> names.add(u.getName()));  // Побочный эффект

List<String> names = new ArrayList<>();
users.parallelStream()  // Добавили параллелизм
    .filter(User::isActive)
    .forEach(u -> names.add(u.getName()));  // Race condition!

// Результат: потерянные элементы, дублирование, ArrayIndexOutOfBoundsException

List<String> names = Collections.synchronizedList(new ArrayList<>());
// или names = new CopyOnWriteArrayList<>(); // ещё хуже по производительности

// Не компонуется: forEach возвращает void
users.stream()
    .filter(User::isActive)
    .forEach(u -> names.add(u.getName()));  // Конец цепочки
    // .map(String::toUpperCase) // Невозможно: forEach уже выполнен

// Корректное использование: логирование
orders.stream()
    .filter(Order::isUrgent)
    .forEach(o -> logger.info("Срочный заказ: {}", o.getId()));

// Корректное использование: запись в потокобезопасный sink
processedItems.parallelStream()
    .forEach(database::save);  // database.save потокобезопасен

// Корректное использование: отправка сообщений в брокер
events.stream()
    .forEach(kafkaTemplate::send);

// Правильно: агрегация через collect
List<String> names = users.stream()
    .filter(User::isActive)
    .map(User::getName)           // Чистая трансформация
    .collect(Collectors.toList()); // Инкапсулированная мутация внутри коллектора

List<String> names = users.parallelStream()
    .filter(User::isActive)
    .map(User::getName)
    .collect(Collectors.toList());  // Корректно при parallel!

// Антипаттерн: мутация в map
AtomicInteger counter = new AtomicInteger(0);
List<Integer> numbered = items.stream()
    .map(item -> {
        int num = counter.incrementAndGet();  // Побочный эффект!
        return num + ": " + item;
    })
    .collect(toList());

// При parallelStream() нумерация будет хаотичной и пропущенной

// Правильно: явная нумерация через индекс
List<String> numbered = IntStream.range(0, items.size())
    .mapToObj(i -> (i + 1) + ": " + items.get(i))
    .collect(toList());

// Или через StreamUtils сторонних библиотек с zipWithIndex

import java.util.*;
import java.util.concurrent.*;

public class Task240226 {
    public static void main(String[] args) {
        List<Integer> source = Arrays.asList(1, 2, 3, 4, 5);
        CopyOnWriteArrayList<Integer> target = new CopyOnWriteArrayList<>();

        long count = source.parallelStream()
                .filter(n -> {
                    target.add(n);
                    return n % 2 == 0;
                })
                .count();

        System.out.println(target.size() + ":" + count);
    }
}

import java.util.*;

public class CollectionFactory {
    
    private final List<String> data = Arrays.asList("a", "b", "c");
    
    //Антипаттерн
    public List<String> bad(boolean cond) {
        if (!cond) return new ArrayList<>(); // Новый объект каждый раз
        return new ArrayList<>(data);
    }
    
    //Правильно
    public List<String> good(boolean cond) {
        if (!cond) return Collections.emptyList(); // Один объект на все вызовы
        if (data.size() == 1) return Collections.singletonList(data.get(0));
        return Collections.unmodifiableList(data); // Защита от модификации
    }
    
    // Для Map и Set
    public Map<String, String> emptyMap() {
        return Collections.emptyMap();
    }
    
    public Set<Integer> singletonSet(Integer value) {
        return value == null ? Collections.emptySet() : Collections.singleton(value);
    }
    
    // Java 9+ альтернатива
    public List<String> java9() {
        return List.of(); // Пустой список
        // return List.of("one"); // С одним элементом
    }
    
    // Важно: иммутабельность
    public void immutable() {
        List<String> empty = Collections.emptyList();
        // empty.add("x"); // UnsupportedOperationException!
    }
}

import java.util.*;

public class Task250226 {
    public static void main(String[] args) {
        List<String> list1 = Collections.emptyList();
        List<String> list2 = Collections.singletonList("hello");
        
        boolean modifiable = false;
        try {
            list1.add("test");
        } catch (Exception e) {
            modifiable = true;
        }
        
        boolean nullElement = false;
        try {
            List<String> list3 = Collections.singletonList(null);
            nullElement = list3.contains(null);
        } catch (Exception e) {
            nullElement = false;
        }
        
        System.out.println(modifiable + " " + nullElement);
    }
}

public class Book {
    private final String title;
    private final String author;
    private final int year;
    private final List<String> genres;  // список жанров для одной книги
    
    // конструктор с genres
    public Book(String title, String author, int year, List<String> genres) {
        this.title = title;
        this.author = author;
        this.year = year;
        // защитная копия или unmodifiableList
        this.genres = genres != null ? new ArrayList<>(genres) : new ArrayList<>();
    }
    
    public List<String> getGenres() {
        return Collections.unmodifiableList(genres);
    }
    
    // остальные геттеры...
}

// В классе Library — метод getAllGenresImperative()
public Set<String> getAllGenresImperative() {
    Set<String> genres = new HashSet<>();
    for (Book book : books) {
        genres.addAll(book.getGenres());  // побочный эффект на genres
    }
    return genres;
}

// В классе Library — метод getAllGenresFunctional()
public Set<String> getAllGenresFunctional() {
    return books.stream()
        .flatMap(book -> book.getGenres().stream())  // Stream<Book> → Stream<String>
        .collect(Collectors.toSet());                 // собираем в Set для уникальности
}