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

public class NumberParser {
    private static final Logger logger = LoggerFactory.getLogger(NumberParser.class);
    
    // Стратегия: обёртка с возвратом Optional
    public List<Integer> parseAllIgnoringErrors(List<String> inputs) {
        return inputs.stream()
            .map(this::safeParse)
            .flatMap(Optional::stream)  // Java 9+: фильтрация пустых Optional
            .collect(Collectors.toList());
    }
    
    private Optional<Integer> safeParse(String input) {
        try {
            return Optional.of(Integer.parseInt(input.trim()));
        } catch (NumberFormatException e) {
            logger.warn("Skipping invalid number: '{}'", input);
            return Optional.empty();
        }
    }
    
    // Стратегия: разделение на успешные и неуспешные
    public ParseResult parseAllWithDetails(List<String> inputs) {
        Map<Boolean, List<Either<String, Integer>>> partitioned = inputs.stream()
            .map(this::parseWithError)
            .collect(Collectors.partitioningBy(Either::isRight));
        
        List<Integer> numbers = partitioned.get(true).stream()
            .map(Either::getRight)
            .collect(Collectors.toList());
        
        List<String> errors = partitioned.get(false).stream()
            .map(Either::getLeft)
            .collect(Collectors.toList());
        
        return new ParseResult(numbers, errors);
    }
    
    private Either<String, Integer> parseWithError(String input) {
        try {
            return Either.right(Integer.parseInt(input.trim()));
        } catch (NumberFormatException e) {
            return Either.left(input);
        }
    }
    
    public record ParseResult(List<Integer> numbers, List<String> failedInputs) {}
}

public class FileProcessor {
    private final FileInputStream inputStream;
    private final BufferedReader reader;
    
    public FileProcessor(String path) throws FileNotFoundException {
        // Если new FileInputStream выбросит исключение,
        // объект FileProcessor не будет создан
        this.inputStream = new FileInputStream(path);
        
        // Эта строка выполнится только если FileInputStream создан успешно
        this.reader = new BufferedReader(new InputStreamReader(inputStream));
    }
}

public class MultiResourceProcessor {
    private final Connection connection;
    private final Statement statement;
    private final ResultSet resultSet;
    
    public MultiResourceProcessor(String query) throws SQLException {
        this.connection = DriverManager.getConnection(DB_URL);
        this.statement = connection.createStatement();
        this.resultSet = statement.executeQuery(query);
    }
}

public MultiResourceProcessor(String query) throws SQLException {
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    
    try {
        conn = DriverManager.getConnection(DB_URL);
        stmt = conn.createStatement();
        rs = stmt.executeQuery(query);
        
        // Все ресурсы созданы успешно — присваиваем полям
        this.connection = conn;
        this.statement = stmt;
        this.resultSet = rs;
    } catch (SQLException e) {
        // Закрытие частично созданных ресурсов
        if (rs != null) try { rs.close(); } catch (SQLException ignored) {}
        if (stmt != null) try { stmt.close(); } catch (SQLException ignored) {}
        if (conn != null) try { conn.close(); } catch (SQLException ignored) {}
        throw e;
    }
}

public class MultiResourceProcessor {
    private final Connection connection;
    private final Statement statement;
    private final ResultSet resultSet;
    
    private MultiResourceProcessor(Connection connection, Statement statement, ResultSet resultSet) {
        this.connection = connection;
        this.statement = statement;
        this.resultSet = resultSet;
    }
    
    public static MultiResourceProcessor create(String query) throws SQLException {
        try (Connection conn = DriverManager.getConnection(DB_URL);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(query)) {
            
            // ResultSet не закроется при выходе из try, так как мы его возвращаем
            // Это требует специальной обработки — см. ниже
            return new MultiResourceProcessor(conn, stmt, rs);
        }
    }
}

public class ConfigHolder {
    private static final Map<String, String> config;
    
    static {
        config = loadConfig();  // Может выбросить RuntimeException
    }
    
    private static Map<String, String> loadConfig() {
        throw new RuntimeException("Configuration file corrupted");
    }
}

java.lang.ExceptionInInitializerError
Caused by: java.lang.RuntimeException: Configuration file corrupted

// Первое обращение — ExceptionInInitializerError
try {
    ConfigHolder holder = new ConfigHolder();
} catch (ExceptionInInitializerError e) {
    // Обработка
}

// Второе обращение — NoClassDefFoundError, даже если причина устранена
try {
    ConfigHolder holder = new ConfigHolder();  // Не работает!
} catch (NoClassDefFoundError e) {
    // Класс навсегда непригоден
}

public class InvalidStatic {
    static {
        throw new IOException("Not allowed");  // Ошибка компиляции
    }
}

public class SafeStaticInit {
    private static final Properties props;
    
    static {
        try {
            props = loadProperties();
        } catch (IOException e) {
            // Оборачиваем checked в ExceptionInInitializerError
            throw new ExceptionInInitializerError(e);
        }
    }
    
    private static Properties loadProperties() throws IOException {
        Properties p = new Properties();
        try (InputStream is = SafeStaticInit.class.getResourceAsStream("/config.properties")) {
            if (is == null) {
                throw new IOException("Config file not found");
            }
            p.load(is);
        }
        return p;
    }
}

// Антипаттерн: избыточная вложенность
static {
    try {
        props = loadProperties();
    } catch (IOException e) {
        throw new RuntimeException(e);  // JVM обернет в ExceptionInInitializerError
    }
}
// Результат: ExceptionInInitializerError -> RuntimeException -> IOException

import java.util.stream.Stream;

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

public class Task280426 {
    public static void main(String[] args) {
        try {
            Stream.of("1", "2", "3")
                    .map(wrap(s -> throwsChecked(s)))
                    .forEach(System.out::print);
        } catch (Exception e) {
            System.out.print("Error");
        }
    }

    static int throwsChecked(String s) throws Exception {
        if (s.equals("2")) throw new Exception("boom");
        return Integer.parseInt(s);
    }

    static <T, R> java.util.function.Function<T, R> wrap(ThrowingFunctionTask280426<T, R, Exception> f) {
        return t -> {
            try {
                return f.apply(t);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        };
    }
}