public class TryWithResourcesOrder {
    
    //Антипаттерн: ресурсы объявлены в неправильном порядке
    public static void badOrder() throws IOException {
        // Сначала создается FileOutputStream, потом BufferedOutputStream
        // Но объявлены наоборот!
        try (BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("file.txt"));
             FileOutputStream fos = new FileOutputStream("file.txt")) {
            // Ошибка: FileOutputStream будет закрыт ПОСЛЕ BufferedOutputStream?
            // Нет, порядок закрытия: fos -> bos (обратный объявлению)
            // Но bos обертывает fos — проблема!
            bos.write("Hello".getBytes());
        } // При закрытии bos попытается сбросить буфер в уже закрытый fos
    }
    
    //Правильно: порядок объявления соответствует вложению
    public static void goodOrder() throws IOException {
        // Внешний ресурс объявлен первым, внутренний — последним
        try (FileOutputStream fos = new FileOutputStream("file.txt");
             BufferedOutputStream bos = new BufferedOutputStream(fos);
             PrintWriter writer = new PrintWriter(bos)) {
            
            writer.println("Hello, World!");
            writer.flush();
            // Порядок закрытия: writer -> bos -> fos (обратный объявлению)
            // Корректно: сначала буферы сбрасываются, потом закрываются потоки
        }
    }
           
    // Демонстрация порядка закрытия
    static class ResourceA implements AutoCloseable {
        ResourceA() { System.out.println("ResourceA created"); }
        @Override public void close() { System.out.println("ResourceA closed"); }
    }
    
    static class ResourceB implements AutoCloseable {
        private final ResourceA dependsOn;
        ResourceB(ResourceA a) { 
            this.dependsOn = a;
            System.out.println("ResourceB created (depends on A)"); 
        }
        @Override public void close() { 
            System.out.println("ResourceB closed (using A)"); 
        }
    }
    
    public static void demonstrateOrder() {
        try (ResourceA a = new ResourceA();
             ResourceB b = new ResourceB(a)) {
            System.out.println("Inside try block");
        }
        // Вывод:
        // ResourceA created
        // ResourceB created (depends on A)
        // Inside try block
        // ResourceB closed (using A)
        // ResourceA closed
        // B закрывается первым, хотя может зависеть от A — это безопасно
    }
    
    public static void main(String[] args) throws Exception {
        demonstrateOrder();
        goodOrder();
        jdbcExample();
    }
}

public class Task270426 {
    static class ResourceA270426 implements AutoCloseable {
        void use() { System.out.print("A"); }
        public void close() { System.out.print("closeA"); }
    }
    
    static class ResourceB270426 implements AutoCloseable {
        ResourceB270426(ResourceA270426 a) { a.use(); }
        public void close() { System.out.print("closeB"); }
    }
    
    public static void main(String[] args) {
        try (ResourceA270426 a = new ResourceA270426();
             ResourceB270426 b = new ResourceB270426(a)) {
            System.out.print("use");
        }
    }
}

// Метод с checked-исключением
public String fetchUrl(String url) throws IOException {
    return httpClient.fetch(url);
}

// Ошибка компиляции: unreported exception IOException
List<String> urls = List.of("http://api1.com", "http://api2.com");
List<String> results = urls.stream()
    .map(this::fetchUrl)  // Не компилируется
    .collect(Collectors.toList());

List<String> results = urls.stream()
    .map(url -> {
        try {
            return fetchUrl(url);
        } catch (IOException e) {
            throw new RuntimeException("Failed to fetch: " + url, e);
        }
    })
    .collect(Collectors.toList());

// Парсинг чисел из списка строк с игнорированием ошибок
List<String> rawValues = List.of("42", "invalid", "17", "3.14", "100");

List<Integer> parsedNumbers = rawValues.stream()
    .map(s -> {
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            // Возвращаем null для невалидных значений
            return null;
        }
    })
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

// Результат: [42, 17, 100]

List<Integer> parsedNumbers = rawValues.stream()
    .map(s -> {
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            logger.warn("Failed to parse integer from '{}'", s);
            return null;
        }
    })
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

@FunctionalInterface
public interface ThrowingFunction<T, R, E extends Exception> {
    R apply(T t) throws E;
}

@FunctionalInterface
public interface ThrowingConsumer<T, E extends Exception> {
    void accept(T t) throws E;
}

@FunctionalInterface
public interface ThrowingSupplier<T, E extends Exception> {
    T get() throws E;
}
Эти интерфейсы позволяют объявлять методы, принимающие функциональные объекты с checked-исключениями:
java
Copy
public <T, R, E extends Exception> List<R> mapWithException(
        List<T> list,
        ThrowingFunction<T, R, E> function) throws E {
    
    List<R> result = new ArrayList<>();
    for (T item : list) {
        result.add(function.apply(item));
    }
    return result;
}

// Использование
List<String> urls = List.of("http://api1.com", "http://api2.com");
try {
    List<String> contents = mapWithException(urls, this::fetchUrl);
} catch (IOException e) {
    // Обработка ошибки
}

public static <T, E extends Exception> Consumer<T> throwingConsumerWrapper(
        ThrowingConsumer<T, E> throwingConsumer) {
    
    return item -> {
        try {
            throwingConsumer.accept(item);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    };
}

// Использование
urls.forEach(throwingConsumerWrapper(url -> {
    writeToFile(url);  // Метод, объявляющий throws IOException
}));

@SuppressWarnings("unchecked")
public static <E extends Throwable> void sneakyThrow(Throwable e) throws E {
    throw (E) e;
}

// Использование в лямбде
List<String> results = urls.stream()
    .map(url -> {
        try {
            return fetchUrl(url);
        } catch (IOException e) {
            sneakyThrow(e);  // Компилятор не требует throws
            return null;     // Недостижимый код, необходим для компиляции
        }
    })
    .collect(Collectors.toList());

// Упрощенная реализация Either (левая сторона — ошибка, правая — успех)
public class Either<L, R> {
    private final L left;
    private final R right;
    private final boolean isLeft;
    
    private Either(L left, R right, boolean isLeft) {
        this.left = left;
        this.right = right;
        this.isLeft = isLeft;
    }
    
    public static <L, R> Either<L, R> left(L value) {
        return new Either<>(value, null, true);
    }
    
    public static <L, R> Either<L, R> right(R value) {
        return new Either<>(null, value, false);
    }
    
    public boolean isLeft() { return isLeft; }
    public boolean isRight() { return !isLeft; }
    public L getLeft() { return left; }
    public R getRight() { return right; }
}

public Either<String, Integer> parseInteger(String input) {
    try {
        return Either.right(Integer.parseInt(input));
    } catch (NumberFormatException e) {
        return Either.left("Invalid number format: " + input);
    }
}

// Обработка в Stream API
List<String> rawValues = List.of("42", "invalid", "17", "not_a_number", "100");

List<Either<String, Integer>> results = rawValues.stream()
    .map(this::parseInteger)
    .collect(Collectors.toList());

List<Integer> successes = results.stream()
    .filter(Either::isRight)
    .map(Either::getRight)
    .collect(Collectors.toList());

List<String> failures = results.stream()
    .filter(Either::isLeft)
    .map(Either::getLeft)
    .collect(Collectors.toList());