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