// Антипаттерн: мутация внешнего списка из потока
List<String> names = new ArrayList<>();
users.stream()
    .filter(User::isActive)
    .forEach(u -> names.add(u.getName()));  // Побочный эффект

List<String> names = new ArrayList<>();
users.parallelStream()  // Добавили параллелизм
    .filter(User::isActive)
    .forEach(u -> names.add(u.getName()));  // Race condition!

// Результат: потерянные элементы, дублирование, ArrayIndexOutOfBoundsException

List<String> names = Collections.synchronizedList(new ArrayList<>());
// или names = new CopyOnWriteArrayList<>(); // ещё хуже по производительности

// Не компонуется: forEach возвращает void
users.stream()
    .filter(User::isActive)
    .forEach(u -> names.add(u.getName()));  // Конец цепочки
    // .map(String::toUpperCase) // Невозможно: forEach уже выполнен

// Корректное использование: логирование
orders.stream()
    .filter(Order::isUrgent)
    .forEach(o -> logger.info("Срочный заказ: {}", o.getId()));

// Корректное использование: запись в потокобезопасный sink
processedItems.parallelStream()
    .forEach(database::save);  // database.save потокобезопасен

// Корректное использование: отправка сообщений в брокер
events.stream()
    .forEach(kafkaTemplate::send);

// Правильно: агрегация через collect
List<String> names = users.stream()
    .filter(User::isActive)
    .map(User::getName)           // Чистая трансформация
    .collect(Collectors.toList()); // Инкапсулированная мутация внутри коллектора

List<String> names = users.parallelStream()
    .filter(User::isActive)
    .map(User::getName)
    .collect(Collectors.toList());  // Корректно при parallel!

// Антипаттерн: мутация в map
AtomicInteger counter = new AtomicInteger(0);
List<Integer> numbered = items.stream()
    .map(item -> {
        int num = counter.incrementAndGet();  // Побочный эффект!
        return num + ": " + item;
    })
    .collect(toList());

// При parallelStream() нумерация будет хаотичной и пропущенной

// Правильно: явная нумерация через индекс
List<String> numbered = IntStream.range(0, items.size())
    .mapToObj(i -> (i + 1) + ": " + items.get(i))
    .collect(toList());

// Или через StreamUtils сторонних библиотек с zipWithIndex

import java.util.*;
import java.util.concurrent.*;

public class Task240226 {
    public static void main(String[] args) {
        List<Integer> source = Arrays.asList(1, 2, 3, 4, 5);
        CopyOnWriteArrayList<Integer> target = new CopyOnWriteArrayList<>();

        long count = source.parallelStream()
                .filter(n -> {
                    target.add(n);
                    return n % 2 == 0;
                })
                .count();

        System.out.println(target.size() + ":" + count);
    }
}

import java.util.*;

public class CollectionFactory {
    
    private final List<String> data = Arrays.asList("a", "b", "c");
    
    //Антипаттерн
    public List<String> bad(boolean cond) {
        if (!cond) return new ArrayList<>(); // Новый объект каждый раз
        return new ArrayList<>(data);
    }
    
    //Правильно
    public List<String> good(boolean cond) {
        if (!cond) return Collections.emptyList(); // Один объект на все вызовы
        if (data.size() == 1) return Collections.singletonList(data.get(0));
        return Collections.unmodifiableList(data); // Защита от модификации
    }
    
    // Для Map и Set
    public Map<String, String> emptyMap() {
        return Collections.emptyMap();
    }
    
    public Set<Integer> singletonSet(Integer value) {
        return value == null ? Collections.emptySet() : Collections.singleton(value);
    }
    
    // Java 9+ альтернатива
    public List<String> java9() {
        return List.of(); // Пустой список
        // return List.of("one"); // С одним элементом
    }
    
    // Важно: иммутабельность
    public void immutable() {
        List<String> empty = Collections.emptyList();
        // empty.add("x"); // UnsupportedOperationException!
    }
}

import java.util.*;

public class Task250226 {
    public static void main(String[] args) {
        List<String> list1 = Collections.emptyList();
        List<String> list2 = Collections.singletonList("hello");
        
        boolean modifiable = false;
        try {
            list1.add("test");
        } catch (Exception e) {
            modifiable = true;
        }
        
        boolean nullElement = false;
        try {
            List<String> list3 = Collections.singletonList(null);
            nullElement = list3.contains(null);
        } catch (Exception e) {
            nullElement = false;
        }
        
        System.out.println(modifiable + " " + nullElement);
    }
}

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