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)

public static Collector<String, ?, String> joiningWithLimit(int maxLength) {
    class StringBuilderWithFlag {
        StringBuilder builder = new StringBuilder();
        boolean truncated = false;
    }
    
    return Collector.of(
        StringBuilderWithFlag::new,                                    // supplier
        (container, str) -> {                                          // accumulator
            if (container.truncated) return;
            if (container.builder.length() + str.length() > maxLength) {
                container.builder.append("[truncated]");
                container.truncated = true;
            } else {
                if (container.builder.length() > 0) container.builder.append(", ");
                container.builder.append(str);
            }
        },
        (left, right) -> {                                             // combiner
            if (left.truncated) return left;
            if (right.truncated) {
                left.builder.append("[truncated]");
                left.truncated = true;
                return left;
            }
            if (left.builder.length() + right.builder.length() > maxLength) {
                left.builder.append(", ").append(right.builder).append("[truncated]");
                left.truncated = true;
            } else {
                if (left.builder.length() > 0) left.builder.append(", ");
                left.builder.append(right.builder);
            }
            return left;
        },
        container -> container.builder.toString(),                      // finisher
        Characteristics.UNORDERED                                       // порядок не важен
    );
}

// Использование
String summary = tags.stream()
    .collect(joiningWithLimit(100));

// Опасно: бросит исключение при повторяющемся авторе
Map<String, Book> bookByAuthor = books.stream()
    .collect(toMap(Book::author, book -> book));  // Crash на второй книге того же автора

// Сохраняем первую встреченную книгу автора
Map<String, Book> firstByAuthor = books.stream()
    .collect(toMap(
        Book::author,
        book -> book,
        (existing, replacement) -> existing  // Игнорируем повторы
    ));

// Сохраняем последнюю, обновляем
Map<String, Book> lastByAuthor = books.stream()
    .collect(toMap(
        Book::author,
        book -> book,
        (oldBook, newBook) -> newBook  // Перезаписываем
    ));

// Агрегируем: список всех книг автора
Map<String, List<Book>> allByAuthor = books.stream()
    .collect(toMap(
        Book::author,
        book -> new ArrayList<>(List.of(book)),  // Создаём список из одной книги
        (existingList, newList) -> {
            existingList.addAll(newList);         // Добавляем к существующему
            return existingList;
        }
    ));

// Опасно: NPE если book.getDescription() возвращает null
Map<String, String> descriptions = books.stream()
    .collect(toMap(Book::title, Book::description));  // Crash на null

// Фильтрация
Map<String, String> validDescriptions = books.stream()
    .filter(b -> b.description() != null)
    .collect(toMap(Book::title, Book::description));

// Обёртка в Optional (требует адаптации типа)
Map<String, Optional<String>> optionalDescriptions = books.stream()
    .collect(toMap(
        Book::title,
        b -> Optional.ofNullable(b.description())
    ));

// Заполнитель с последующей фильтрацией
String NULL_MARKER = "\u0000";
Map<String, String> markedDescriptions = books.stream()
    .collect(toMap(
        Book::title,
        b -> b.description() != null ? b.description() : NULL_MARKER
    ));
// При использовании: if (!value.equals(NULL_MARKER))

// Опасно: ключ — изменяемый объект
record MutableKey(String name) {
    public void setName(String name) { this.name = name; }  // Mutable!
}

Map<MutableKey, Book> map = books.stream()
    .collect(toMap(book -> new MutableKey(book.author()), book -> book));

// Последующая модификация ключа делает Map некорректным
map.keySet().iterator().next().setName("Changed");  // Неопределённое поведение

// Немодифицируемый список
List<Book> unmodifiable = books.stream()
    .collect(collectingAndThen(toList(), Collections::unmodifiableList));

// Строка из списка с префиксом и суффиксом
String joined = books.stream()
    .map(Book::title)
    .collect(collectingAndThen(
        joining(", "),
        str -> "Titles: " + str + "."
    ));

// Группировка только ненулевых описаний по жанру
Map<Genre, List<String>> descriptionsByGenre = books.stream()
    .collect(groupingBy(
        Book::genre,
        filtering(
            b -> b.description() != null,
            mapping(Book::description, toList())
        )
    ));

// Средняя цена по авторам (автор -> средняя цена его книг)
Map<String, Double> avgPriceByAuthor = books.stream()
    .collect(groupingBy(
        Book::author,
        mapping(Book::price, averagingDouble(BigDecimal::doubleValue))
    ));