// Извлечение из CSV
try (Stream<String> lines = Files.lines(Path.of("input.csv"));
     // Загрузка в выходной файл
     BufferedWriter writer = Files.newBufferedWriter(Path.of("output.json"))) {
    
    lines.skip(1)  // Пропуск заголовка
        .map(this::parseCsvLine)           // String -> Record
        .filter(Objects::nonNull)            // Удаление malformed
        .map(this::transformToJson)          // Record -> JSON string
        .forEach(json -> {
            try {
                writer.write(json);
                writer.newLine();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        });
}

try (Stream<String> lines = Files.lines(Path.of("corrupt.txt"))) {
    lines.map(this::parse)
        .filter(Objects::nonNull)
        .forEach(this::process);
    // Если parse бросает RuntimeException на 1000-й строке,
    // lines.close() вызывается автоматически
}

// Антипаттерн: ресурс внутри map
lines.map(line -> {
    Connection conn = pool.borrow();  // Открытие здесь
    return query(conn, line);         // Если исключение, conn не возвращается
})

// Правильно: try-with-resources внутри лямбды, или вне потока

import java.io.*;

public class Task060426 {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        dos.writeInt(255);
        dos.flush();

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        DataInputStream dis = new DataInputStream(bais);
        
        int value = dis.read();
        System.out.println(value);
    }
}

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;

public class ParallelStreamTimeout {
    
    //Антипаттерн: parallelStream без контроля тайм-аута
    public static List<Integer> dangerousParallel() {
        List<Integer> numbers = IntStream.range(0, 10).boxed().collect(Collectors.toList());
        
        return numbers.parallelStream()
            .map(n -> {
                // Представьте, что здесь долгий внешний вызов
                try { Thread.sleep(100_000); } catch (InterruptedException e) {}
                return n * 2;
            })
            .collect(Collectors.toList());
        // Зависнет навсегда, общий pool заблокирован
    }
    
    //Решение: явный ExecutorService с тайм-аутом
    public static List<Integer> safeWithExecutor(List<Integer> numbers) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        List<Future<Integer>> futures = numbers.stream()
            .map(n -> executor.submit(() -> {
                // Симуляция долгой операции
                Thread.sleep(100); // реальная логика
                return n * 2;
            }))
            .collect(Collectors.toList());
        
        List<Integer> result = new ArrayList<>();
        for (Future<Integer> future : futures) {
            try {
                // Тайм-аут 1 секунда на задачу
                result.add(future.get(1, TimeUnit.SECONDS));
            } catch (TimeoutException e) {
                future.cancel(true); // Попытка прервать
                result.add(null); // или обработка ошибки
                System.err.println("Задача не уложилась в тайм-аут");
            } catch (ExecutionException e) {
                throw new RuntimeException(e.getCause());
            }
        }
        executor.shutdown();
        return result;
    }
    
    //Альтернатива: CompletableFuture с тайм-аутом (Java 9+)
    public static CompletableFuture<List<Integer>> asyncWithTimeout(List<Integer> numbers) {
        List<CompletableFuture<Integer>> futures = numbers.stream()
            .map(n -> CompletableFuture.supplyAsync(() -> {
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                return n * 2;
            }).orTimeout(500, TimeUnit.MILLISECONDS)  // Тайм-аут 500 мс
              .exceptionally(ex -> {
                  System.err.println("Ошибка или тайм-аут: " + ex.getMessage());

                  return -1; // значение по умолчанию
              }))
            .collect(Collectors.toList());
        
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream().map(CompletableFuture::join).collect(Collectors.toList()));
    }
    
    // Изолированный ForkJoinPool (тоже без тайм-аута)
    public static void isolatedPool() throws Exception {
        ForkJoinPool customPool = new ForkJoinPool(4);
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
        
        customPool.submit(() -> 
            numbers.parallelStream().forEach(n -> {
                // Операция
            })
        ).get(1, TimeUnit.SECONDS); // Тайм-аут на весь стрим, не на отдельные элементы
        customPool.shutdown();
    }
    
    public static void main(String[] args) throws InterruptedException {
        List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
        safeWithExecutor(data);
    }
}

package oleborn.taskswithspring.tasks.year2026;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;

public class Task070426 {
    public static void main(String[] args) throws Exception {
        AtomicInteger interruptedCount = new AtomicInteger(0);
        ForkJoinPool pool = new ForkJoinPool(4);

        Thread worker = new Thread(() -> {
            pool.submit(() -> {
                IntStream.range(0, 4).parallel().forEach(i -> {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        interruptedCount.incrementAndGet();
                    }
                });
            }).join();
        });

        worker.start();
        Thread.sleep(1000);
        worker.interrupt();
        worker.join();
        pool.shutdown();

        System.out.println(interruptedCount.get());
    }
}

java.lang.Object
    └── java.lang.Throwable (checked)
        ├── java.lang.Error (unchecked)
        │   ├── OutOfMemoryError
        │   ├── StackOverflowError
        │   ├── NoClassDefFoundError
        │   └── ...
        └── java.lang.Exception (checked)
            ├── IOException
            ├── SQLException
            └── java.lang.RuntimeException (unchecked)
                ├── NullPointerException
                ├── IllegalArgumentException
                ├── IllegalStateException
                └── ...

public class ErrorHandlingDemo {
    
    public static void main(String[] args) {
        try {
            recursiveCall(0);
        } catch (StackOverflowError e) {
            // Технически возможно, но бесполезно
            System.out.println("Stack overflow caught: " + e.getMessage());
            // Попытка продолжить работу здесь крайне опасна
            // JVM находится в нестабильном состоянии
        }
    }
    
    private static void recursiveCall(int depth) {
        // Каждый вызов добавляет фрейм в стек
        recursiveCall(depth + 1);
    }
}

// Проверяемое исключение для восстановимых бизнес-ошибок
public class PaymentProcessingException extends Exception {
    private final String transactionId;
    private final PaymentErrorCode errorCode;
    
    public PaymentProcessingException(String message, String transactionId, 
                                     PaymentErrorCode errorCode, Throwable cause) {
        super(message, cause);
        this.transactionId = transactionId;
        this.errorCode = errorCode;
    }
    
    // Геттеры для структурированной информации об ошибке
    public String getTransactionId() { return transactionId; }
    public PaymentErrorCode getErrorCode() { return errorCode; }
}

// Непроверяемое исключение для программных ошибок валидации
public class InvalidPaymentRequestException extends RuntimeException {
    private final String fieldName;
    private final Object rejectedValue;
    
    public InvalidPaymentRequestException(String fieldName, Object rejectedValue, String message) {
        super(message);
        this.fieldName = fieldName;
        this.rejectedValue = rejectedValue;
    }
}

// Антипаттерн — никогда так не делайте
public void processRequest(Request request) {
    try {
        executeBusinessLogic(request);
    } catch (Throwable t) {  // Опасно: перехватывает Error
        logger.error("Request failed", t);
        // Если это был OutOfMemoryError, приложение продолжит работу
        // с нестабильной JVM, что приведет к непредсказуемым последствиям
    }
}

public User loadUserById(String userId) throws UserRepositoryException {
    try {
        return database.executeQuery("SELECT * FROM users WHERE id = ?", userId);
    } catch (SQLException e) {
        // Сохраняем оригинальное исключение как cause
        throw new UserRepositoryException(
            "Failed to load user with ID: " + userId, 
            e  // Цепочка причин сохраняется
        );
    }
}

public class Task080426 {
    public static void main(String[] args) {
        try {
            throw new NullPointerException();
        } catch (Throwable t) {
            System.out.print("A");
            throw new RuntimeException();
        } finally {
            System.out.print("B");
        }
    }
}

public class ClassLoaderLeakExample {
    
    //Антипаттерн: статическое поле хранит класс, загруженный динамическим ClassLoader'ом
    private static Class<?> CACHED_CLASS;
    
    public static void dangerousStore(Class<?> clazz) {
        CACHED_CLASS = clazz; // Удерживает ClassLoader навсегда
    }
    
    //Антипаттерн: ThreadLocal без очистки
    private static final ThreadLocal<Object> THREAD_LOCAL = new ThreadLocal<>();
    
    public static void dangerousThreadLocal() {
        THREAD_LOCAL.set(new Object()); // Поток из пула может пережить перезагрузку
    }
    
    //Решение: очистка ThreadLocal в finally или в слушателе
    public static void safeThreadLocal() {
        try {
            THREAD_LOCAL.set(new Object());
            // работа
        } finally {
            THREAD_LOCAL.remove(); // Обязательно
        }
    }
    
    //Решение для веб-приложений: слушатель контекста
    public static class CleanupListener implements ServletContextListener {
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
            // Дерегистрация JDBC-драйверов
            Enumeration<Driver> drivers = DriverManager.getDrivers();
            while (drivers.hasMoreElements()) {
                Driver driver = drivers.nextElement();
                if (driver.getClass().getClassLoader() == 
                    Thread.currentThread().getContextClassLoader()) {
                    try {
                        DriverManager.deregisterDriver(driver);
                    } catch (Exception e) { /* log */ }
                }
            }
            
            // Очистка статических кешей логирования (Log4j, Logback)
            // org.slf4j.LoggerFactory.getILoggerFactory().reset();
            
            // Остановка фоновых потоков
            // Thread.interruptAll() и т.п.
        }
    }
}

import java.lang.ref.WeakReference;

public class Task090426 {
    public static void main(String[] args) {
        Object obj = new Object();
        WeakReference<Object> ref = new WeakReference<>(obj);
        obj = null;
        System.gc();
        System.out.println(ref.get());
    }
}