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)

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