// Метод с 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);
            }
        };
    }
}

public class SubListViewExample {
    
    public static void main(String[] args) {
        List<Integer> original = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        
        // Создаем view на подсписок
        List<Integer> sub = original.subList(2, 5);
        System.out.println("Sublist (view): " + sub); // [3, 4, 5]
        
        //Опасность 1: изменение view меняет оригинал
        sub.set(0, 99);
        sub.add(100);
        System.out.println("Original after modifying view: " + original);
        // [1, 2, 99, 4, 5, 100, 6, 7, 8] — оригинал изменился!
        
        //Опасность 2: модификация оригинала ломает view
        try {
            original.add(999); // структурная модификация оригинала
            sub.get(0);       // ConcurrentModificationException!
        } catch (ConcurrentModificationException e) {
            System.out.println("View сломан: " + e);
        }
        
        // Восстановим списки для демонстрации
        original = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        sub = original.subList(2, 5);
        
        //Решение 1: копирование для независимой работы
        List<Integer> copy = new ArrayList<>(original.subList(2, 5));
        copy.set(0, 999);
        copy.add(1000);
        System.out.println("Original unchanged: " + original); // [1, 2, 3, 4, 5, 6, 7, 8]
        System.out.println("Independent copy: " + copy);       // [999, 4, 5, 1000]
        
        //Решение 2: работа только с view без трогания оригинала
        List<Integer> list = new ArrayList<>(Arrays.asList(10, 20, 30, 40, 50));
        List<Integer> view = list.subList(1, 4);
        // Можно безопасно читать view
        System.out.println("View: " + view); // [20, 30, 40]
        // Можно менять элементы через set (не структурная модификация)
        view.set(1, 999);
        System.out.println("Original after set: " + list); // [10, 20, 999, 40, 50]
        // НО нельзя добавлять/удалять из оригинала
        // list.remove(0); // сломает view!
        
        //Альтернатива: Java 8+ Stream для создания копии
        List<Integer> streamCopy = original.stream().skip(2).limit(3).collect(Collectors.toList());
        System.out.println("Stream copy: " + streamCopy);
    }
}

import java.util.*;

public class Task290426 {
    public static void main(String[] args) {
        List<Integer> original = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        List<Integer> sub = original.subList(1, 4);
        
        sub.add(99);
        original.add(100);
        
        System.out.println(sub.size());
        System.out.println(original.size());
    }
}

public void processOrder(Order order) {
    if (order == null) {
        throw new NullPointerException("Order cannot be null");
    }
    // Основная логика
}

// 1. Базовая версия без сообщения
public static <T> T requireNonNull(T obj)

// 2. Версия со статическим сообщением
public static <T> T requireNonNull(T obj, String message)

// 3. Версия с ленивым сообщением через Supplier
public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier)

public class OrderService {
    private final OrderRepository repository;
    
    public OrderService(OrderRepository repository) {
        this.repository = Objects.requireNonNull(repository);
    }
}

public void updateInventory(Inventory inventory, String warehouseId) {
    Objects.requireNonNull(inventory, "Inventory object cannot be null");
    Objects.requireNonNull(warehouseId, "Warehouse ID must be specified");
    
    inventory.adjustStock(warehouseId);
}

public void processTransaction(Transaction tx) {
    Objects.requireNonNull(tx, 
        () -> String.format("Transaction cannot be null at %s", Instant.now()));
    
    // Сложное форматирование выполняется только если tx == null
}

// Избыточно: сообщение формируется всегда
Objects.requireNonNull(user, "User " + userId + " not found in database " + dbName);

// Эффективно: сообщение формируется только при null
Objects.requireNonNull(user, 
    () -> "User " + userId + " not found in database " + dbName);