// Плохо: ресурс может остаться открытым при исключении
public List<Book> importFromJsonManual(String filename) {
    FileReader reader = null;
    try {
        reader = new FileReader(filename);
        // ... парсинг ...
        return parseBooks(reader);
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        if (reader != null) {
            try {
                reader.close();  // Может бросить исключение, подавляя основное
            } catch (IOException e) {
                // игнорируем
            }
        }
    }
}

// Хорошо: автоматическое закрытие, правильная обработка исключений
public List<Book> importFromJson(String filename) {
    try (FileReader reader = new FileReader(filename);
         BufferedReader buffered = new BufferedReader(reader)) {
        
        StringBuilder json = new StringBuilder();
        String line;
        while ((line = buffered.readLine()) != null) {
            json.append(line);
        }
        return parseBooks(json.toString());
        
    } catch (IOException e) {
        throw new LibraryException("Не удалось прочитать файл: " + filename, e);
    }
}

public void exportToJson(String inputFilename, String outputFilename) {
    try (BufferedReader reader = Files.newBufferedReader(Path.of(inputFilename));
         BufferedWriter writer = Files.newBufferedWriter(Path.of(outputFilename))) {
        
        String json = reader.readLine();
        List<Book> books = parseBooks(json);
        String formatted = formatBooks(books);
        writer.write(formatted);
        
    } catch (IOException e) {
        throw new LibraryException("Ошибка при копировании данных", e);
    }
}

public class LibraryException extends RuntimeException {
    
    public LibraryException(String message) {
        super(message);
    }
    
    public LibraryException(String message, Throwable cause) {
        super(message, cause);
    }
    
    public LibraryException(String message, String bookId, Throwable cause) {
        super(message + " [книга: " + bookId + "]", cause);
    }
}

public Book findBookOrThrow(String bookId) {
    return findById(bookId)
        .orElseThrow(() -> new LibraryException("Книга не найдена", bookId, null));
}

public List<Book> loadFromMultipleSources(String jsonPath, String csvPath) {
    List<Book> result = new ArrayList<>();
    
    try {
        result.addAll(loadJson(jsonPath));
    } catch (FileNotFoundException | NoSuchFileException e) {
        // Файла нет — не критично, продолжаем с CSV
        System.err.println("JSON не найден, пробуем CSV: " + e.getMessage());
    } catch (IOException e) {
        throw new LibraryException("Ошибка чтения JSON", e);
    }
    
    try {
        result.addAll(loadCsv(csvPath));
    } catch (FileNotFoundException | NoSuchFileException e) {
        System.err.println("CSV не найден: " + e.getMessage());
    } catch (IOException e) {
        throw new LibraryException("Ошибка чтения CSV", e);
    }
    
    if (result.isEmpty()) {
        throw new LibraryException("Не удалось загрузить книги ни из одного источника");
    }
    
    return result;
}

// Не компилируется: parseDate бросает checked DateTimeParseException
public List<LocalDate> parsePublicationDates(List<String> dateStrings) {
    return dateStrings.stream()
        .map(this::parseDate)  // Ошибка: unreported exception
        .collect(Collectors.toList());
}

private LocalDate parseDate(String s) throws DateTimeParseException {
    return LocalDate.parse(s);  // checked в Java 8, но...
}

// Реальная проблема: Files.readString бросает IOException
public List<String> loadDescriptions(List<Path> paths) {
    return paths.stream()
        .map(Files::readString)  // Ошибка: IOException не обработана
        .collect(Collectors.toList());
}

public List<String> loadDescriptionsWrapped(List<Path> paths) {
    return paths.stream()
        .map(path -> {
            try {
                return Files.readString(path);
            } catch (IOException e) {
                throw new LibraryException("Не удалось прочитать: " + path, e);
            }
        })
        .collect(Collectors.toList());
}

// Утилитный метод для оборачивания checked в unchecked
@FunctionalInterface
public interface ThrowingFunction<T, R> {
    R apply(T t) throws Exception;
}

public static <T, R> Function<T, R> wrap(ThrowingFunction<T, R> throwing) {
    return t -> {
        try {
            return throwing.apply(t);
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new LibraryException("Ошибка в потоковой операции", e);
        }
    };
}

public List<String> loadDescriptionsClean(List<Path> paths) {
    return paths.stream()
        .map(wrap(Files::readString))
        .collect(Collectors.toList());
}

public Optional<Book> parseBookFromJson(String json) {
    return Optional.ofNullable(json)
        .map(wrap(this::parseBook))
        .orElseThrow(() -> new LibraryException("Пустой JSON"));
}

private Book parseBook(String json) throws JsonParseException {
    // парсинг...
}

public void addBook(Book book) {
    Objects.requireNonNull(book, "Книга не может быть null");
    Objects.requireNonNull(book.getTitle(), "Название не может быть null");
    
    if (book.getYear() < 1450 || book.getYear() > Year.now().getValue() + 1) {
        throw new IllegalArgumentException("Недопустимый год: " + book.getYear());
    }
    
    books.add(book);
}

public Book findById(String id) {
    Objects.requireNonNull(id, () -> "ID книги не может быть null, доступные: " + listIds());
    // ленивое вычисление сообщения — вызывается только при ошибке
    return internalFind(id);
}

public Book getBook(String bookId) {
    return findById(bookId)
        .orElseThrow(() -> new LibraryException("Книга не найдена", bookId, null));
}

public LocalDate getPublicationDate(String bookId) {
    return findById(bookId)
        .map(Book::getPublishedDate)
        .filter(Objects::nonNull)
        .orElseThrow(() -> new LibraryException("Дата неизвестна", bookId, null));
}

public class Library {
    private final List<Book> books = new ArrayList<>();
    
    public void addBook(Book book) {
        Objects.requireNonNull(book, "Книга не может быть null");
        Objects.requireNonNull(book.getId(), "ID книги не может быть null");
        
        if (findById(book.getId()).isPresent()) {
            throw new LibraryException("Книга с ID " + book.getId() + " уже существует");
        }
        
        books.add(book);
    }
    
    public Book getBook(String id) {
        Objects.requireNonNull(id, "ID не может быть null");
        return findById(id)
            .orElseThrow(() -> new LibraryException("Книга не найдена", id, null));
    }
    
    public List<Book> importFromJson(String filename) {
        Objects.requireNonNull(filename, "Имя файла не может быть null");
        
        try (BufferedReader reader = Files.newBufferedReader(Path.of(filename))) {
            String json = reader.lines().collect(Collectors.joining());
            return parseBooks(json);
        } catch (FileNotFoundException | NoSuchFileException e) {
            throw new LibraryException("Файл не найден: " + filename, e);
        } catch (IOException e) {
            throw new LibraryException("Ошибка чтения файла: " + filename, e);
        }
    }
    
    public List<Book> importFromMultipleSources(List<String> filenames) {
        Objects.requireNonNull(filenames, "Список файлов не может быть null");
        
        return filenames.stream()
            .filter(Objects::nonNull)
            .map(wrap(this::importFromJson))
            .flatMap(List::stream)
            .collect(Collectors.toList());
    }
    
    private Optional<Book> findById(String id) {
        return books.stream()
            .filter(b -> b.getId().equals(id))
            .findFirst();
    }
    
    private List<Book> parseBooks(String json) {
        // реализация парсинга
    }
}

public List<LocalDate> parseDatesWithFallback(List<String> inputs) {
    // Парсит даты, при ошибке возвращает LocalDate.MIN вместо исключения
    // Используйте обёртку, возвращающую Optional<LocalDate>
}

class Parent040526 {
    static void print() {
        System.out.println("Parent");
    }
}

class Child040526 extends Parent040526 {
    static void print() {
        System.out.println("Child");
    }
}

public class Task040526 {
    public static void main(String[] args) {
        Parent040526 obj1 = new Parent040526();
        Parent040526 obj2 = new Child040526();
        Child040526 obj3 = new Child040526();
        
        obj1.print();
        obj2.print();
        obj3.print();
    }
}

import java.util.*;

public class ImmutableCollections {
    
    public static void main(String[] args) {
        //Антипаттерн: попытка модифицировать иммутабельные коллекции
        
        // Collections.emptyList()
        List<String> empty = Collections.emptyList();
        try {
            empty.add("item"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add to emptyList: " + e);
        }
        
        // List.of() (Java 9+)
        List<String> of = List.of("A", "B", "C");
        try {
            of.add("D"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add to List.of: " + e);
        }
        
        try {
            of.set(0, "Z"); // Тоже исключение! Даже замена элемента запрещена
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot set in List.of: " + e);
        }
        
        // Collections.singletonList()
        List<String> singleton = Collections.singletonList("only");
        try {
            singleton.add("second"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add to singletonList: " + e);
        }
        
        //Правильное использование: read-only операции
        List<String> readOnly = List.of("Red", "Green", "Blue");
        for (String color : readOnly) {
            System.out.print(color + " ");
        }
        System.out.println();
        String first = readOnly.get(0);
        boolean contains = readOnly.contains("Green");
        
        //Решение 1: создание изменяемой копии
        List<String> mutable = new ArrayList<>(readOnly);
        mutable.add("Yellow");
        mutable.set(0, "Cyan");
        System.out.println("Mutable copy: " + mutable);
        
        //Решение 2: создание изменяемой пустой коллекции
        List<String> mutableEmpty = new ArrayList<>();
        mutableEmpty.add("item"); // Работает
        
        //Решение 3: защитное копирование в API
        public static List<String> getInternalList() {
            // Возвращаем иммутабельный список, чтобы защитить внутреннее состояние
            return List.of("internal1", "internal2");
        }
        
        // Получатель, который хочет модифицировать:
        List<String> fromApi = getInternalList();
        List<String> myWorkingCopy = new ArrayList<>(fromApi);
        myWorkingCopy.add("myItem");
        
        // Различия между видами иммутабельных списков
        List<String> oldStyleEmpty = Collections.emptyList(); // Пустой, иммутабельный
        List<String> newStyleEmpty = List.of();              // То же самое, но короче
        
        List<String> oldStyleSingle = Collections.singletonList("one");
        List<String> newStyleSingle = List.of("one");
        
        // List.of() не допускает null
        try {
            List.of("a", null, "b"); // NullPointerException
        } catch (NullPointerException e) {
            System.out.println("List.of() rejects nulls");
        }
        
        // Collections.emptyList() допускает null? Нет, при добавлении, но сам список может содержать null? 
        // Сам список пуст, но методы типа contains(null) работают без исключения
        System.out.println("emptyList contains null: " + Collections.emptyList().contains(null)); // false
    }
}

import java.util.*;

public class Task050526 {
    public static void main(String[] args) {
        List<String> list1 = Collections.emptyList();
        List<String> list2 = List.of();
        List<String> list3 = new ArrayList<>(List.of("a", "b"));
        List<String> list4 = list3.subList(0, 2);

        list1.add("x");
        list2.add("x");
        list3.add("x");
        list4.add("x");

        System.out.println("Done");
    }
}