public class Book {
    private final String title;
    private final String author;
    private final int year;
    private final List<String> genres;  // список жанров для одной книги
    
    // конструктор с genres
    public Book(String title, String author, int year, List<String> genres) {
        this.title = title;
        this.author = author;
        this.year = year;
        // защитная копия или unmodifiableList
        this.genres = genres != null ? new ArrayList<>(genres) : new ArrayList<>();
    }
    
    public List<String> getGenres() {
        return Collections.unmodifiableList(genres);
    }
    
    // остальные геттеры...
}

// В классе Library — метод getAllGenresImperative()
public Set<String> getAllGenresImperative() {
    Set<String> genres = new HashSet<>();
    for (Book book : books) {
        genres.addAll(book.getGenres());  // побочный эффект на genres
    }
    return genres;
}

// В классе Library — метод getAllGenresFunctional()
public Set<String> getAllGenresFunctional() {
    return books.stream()
        .flatMap(book -> book.getGenres().stream())  // Stream<Book> → Stream<String>
        .collect(Collectors.toSet());                 // собираем в Set для уникальности
}

public Set<String> getClassicGenresSorted() {
    return books.stream()
        .filter(book -> book.getYear() < 1950)           // только старые книги
        .flatMap(book -> book.getGenres().stream())
        .filter(genre -> !genre.equals("Фэнтези"))        // исключаем современное
        .sorted()                                         // сортировка (временно в Stream)
        .collect(Collectors.toCollection(LinkedHashSet::new));  // сохраняем порядок
}

["1999", "invalid", "2005", "nineteen", "2020", ""]

// Не делайте так
List<Integer> years = new ArrayList<>();
for (String s : yearStrings) {
    try {
        years.add(Integer.parseInt(s));
    } catch (NumberFormatException e) {
        // игнорируем — но где гарантия, что мы ничего не пропустили?
    }
}

// В отдельном классе-утилите или в Library
private static Optional<Integer> safeParseYear(String yearString) {
    try {
        return Optional.of(Integer.parseInt(yearString));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

public List<Integer> parseValidYears(List<String> yearStrings) {
    return yearStrings.stream()
        .flatMap(s -> safeParseYear(s).stream())  // Optional → Stream (0 или 1 элемента)
        .collect(Collectors.toList());
}

.flatMap(s -> safeParseYear(s).map(Stream::of).orElseGet(Stream::empty))

public boolean isValidGenre(String genre) {
    return getAllGenresFunctional().contains(genre);
}

public void addBookWithGenreValidation(Book book) {
    for (String genre : book.getGenres()) {
        if (!isValidGenre(genre) && !books.isEmpty()) {
            System.out.println("Предупреждение: новый жанр '" + genre + "'");
        }
    }
    addBook(book);
}

public Map<String, Long> getGenreStatistics() {
    return books.stream()
        .flatMap(book -> book.getGenres().stream())
        .collect(Collectors.groupingBy(
            genre -> genre,
            Collectors.counting()
        ));
}

public List<Book> importBooksFromRawData(List<String[]> rawData) {
    return rawData.stream()
        .flatMap(row -> {
            Optional<String> title = Optional.ofNullable(row[0]);
            Optional<String> author = Optional.ofNullable(row[1]);
            Optional<Integer> year = safeParseYear(row[2]);
            List<String> genres = row.length > 3 
                ? Arrays.asList(row[3].split(",")) 
                : Collections.emptyList();
            
            // создаём книгу только если все обязательные поля валидны
            return title.flatMap(t -> 
                author.flatMap(a -> 
                    year.map(y -> new Book(t, a, y, genres))
                )
            ).stream();
        })
        .collect(Collectors.toList());
}

// Ожидаемый результат:
// { "Толстой"=["Роман", "Исторический"], 
//   "Оруэлл"=["Антиутопия", "Сатира"] }

public class Task260225 {
    public static void main(String[] args) {
        float a = 0.1f;
        double b = 0.1;
        
        System.out.println(a == 0.1);
        System.out.println(b == 0.1);
        System.out.println(a == 0.1f);
        System.out.println(a == (float)0.1);
    }
}

import java.io.*;

public class FinallyReturn {
    
    //Антипаттерн: return в finally
    public static int badExample() {
        try {
            System.out.println("Try");
            return 42; // Этот return будет проигнорирован
        } finally {
            System.out.println("Finally");
            return 100; // Перекрывает return из try
        }
    }
    
    //Еще хуже: finally "проглатывает" исключение
    public static int badWithException() {
        try {
            throw new RuntimeException("Ошибка в try");
        } finally {
            return 200; // Исключение ПРОПАДАЕТ!
        }
    }
    
    //Правильно: finally без return
    public static int goodExample() {
        try {
            System.out.println("Try");
            return 42; // Нормальный выход
        } finally {
            System.out.println("Finally");
            // Здесь только очистка, без return
        }
    }
    
    //Правильно с исключением
    public static int goodWithException() throws IOException {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("file.txt"));
            return Integer.parseInt(reader.readLine());
        } finally {
            if (reader != null) {
                try {
                    reader.close(); // Только закрытие, return нет
                } catch (IOException e) {
                    // Логируем, но не перезаписываем исходное исключение
                }
            }
        }
    }
    
    // Демонстрация
    public static void main(String[] args) {
        System.out.println("badExample(): " + badExample()); 
        // Вывод: Try, Finally, 100 (а не 42!)
        
        System.out.println("badWithException(): " + badWithException());
        // Исключение не выбрасывается, выводит 200
        
        System.out.println("goodExample(): " + goodExample());
        // Вывод: Try, Finally, 42 (корректно)
    }
}

public class Task270226 {
    public static void main(String[] args) {
        System.out.println(test());
    }
    
    static String test() {
        try {
            System.exit(0);
            return "try";
        } catch (Exception e) {
            return "catch";
        } finally {
            return "finally";
        }
    }
}

// Для toList(): () -> new ArrayList<T>()
// Для toSet(): () -> new HashSet<T>()
// Для toMap(): () -> new HashMap<K, V>()

// Для toList(): (list, element) -> list.add(element)
// Для toMap(): (map, element) -> map.put(keyExtractor.apply(element), valueExtractor.apply(element))

// Для toList(): (left, right) -> { left.addAll(right); return left; }
// Для toSet(): (left, right) -> { left.addAll(right); return left; }

// collectingAndThen(toList(), Collections::unmodifiableList)
// finisher: list -> Collections.unmodifiableList(list)