import java.util.*;

public class HashSetMutation {
    
    static class MutablePoint {
        private int x;
        private int y;
        
        public MutablePoint(int x, int y) {
            this.x = x;
            this.y = y;
        }
        
        public void setX(int x) { this.x = x; }
        public void setY(int y) { this.y = y; }
        
        @Override
        public boolean equals(Object o) {
            if (!(o instanceof MutablePoint)) return false;
            MutablePoint p = (MutablePoint) o;
            return x == p.x && y == p.y;
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(x, y);
        }
        
        @Override
        public String toString() {
            return "(" + x + "," + y + ")";
        }
    }
    
    public static void main(String[] args) {
        Set<MutablePoint> points = new HashSet<>();
        
        MutablePoint p = new MutablePoint(1, 2);
        points.add(p);
        System.out.println("Contains (1,2): " + points.contains(p)); // true
        
        //Антипаттерн: изменение после добавления
        p.setX(5);
        System.out.println("Contains (5,2): " + points.contains(p)); // false — объект потерян!
        System.out.println("Set size: " + points.size()); // 1, но внутри лежит объект (1,2) в другой корзине
        
        // Объект невозможно удалить
        points.remove(p); // false
        System.out.println("Size after remove: " + points.size()); // всё ещё 1
        
        //Правильно: удалить перед изменением, потом добавить заново
        MutablePoint p2 = new MutablePoint(10, 20);
        points.add(p2);
        points.remove(p2);
        p2.setX(30);
        points.add(p2);
        System.out.println("Contains (30,20): " + points.contains(p2)); // true
        
        //Лучшее решение: неизменяемые объекты
        record ImmutablePoint(int x, int y) {}
        
        Set<ImmutablePoint> immutableSet = new HashSet<>();
        ImmutablePoint ip = new ImmutablePoint(1, 2);
        immutableSet.add(ip);
        // ip.x нельзя изменить — компилятор запретит
        immutableSet.contains(ip); // всегда корректно
    }
}

import java.util.HashSet;

public class Task300326 {
    static class Item300326 {
        int id;
        
        Item300326(int id) { this.id = id; }
        
        public boolean equals(Object o) {
            return o instanceof Item300326 && ((Item300326) o).id == id;
        }
        public int hashCode() {
            return id;
        }
    }

    public static void main(String[] args) {
        HashSet<Item300326> set = new HashSet<>();
        Item300326 a = new Item300326(1);
        Item300326 b = new Item300326(2);
        set.add(a);
        set.add(b);

        a.id = 2;  // изменяем объект, уже находящийся в множестве

        System.out.print(set.contains(a) + " ");
        System.out.print(set.contains(b) + " ");
        System.out.print(set.remove(a) + " ");
        System.out.print(set.size());
    }
}

public Map<String, AuthorStats> calculateAuthorStatsLegacy(List<Book> books, int minYear) {
    Map<String, AuthorStats> result = new HashMap<>();
    
    for (Book book : books) {
        // Пропускаем старые книги
        if (book.getYear() < minYear) {
            continue;
        }
        
        // Пропускаем без жанров
        if (book.getGenres().isEmpty()) {
            continue;
        }
        
        // Пропускаем, если нет цены
        Double price = book.getPrice();
        if (price == null || price <= 0) {
            continue;
        }
        
        String author = book.getAuthor();
        AuthorStats stats = result.get(author);
        
        if (stats == null) {
            stats = new AuthorStats();
            stats.firstBookYear = book.getYear();
            result.put(author, stats);
        }
        
        // Обновляем статистику
        stats.bookCount++;
        stats.totalPages += book.getPages();
        stats.totalPrice += price;
        
        // Обновляем самую старую книгу
        if (book.getYear() < stats.firstBookYear) {
            stats.firstBookYear = book.getYear();
        }
        
        // Собираем уникальные жанры
        for (String genre : book.getGenres()) {
            if (!stats.genres.contains(genre)) {
                stats.genres.add(genre);
            }
        }
    }
    
    // Пост-обработка: считаем среднее
    for (AuthorStats stats : result.values()) {
        stats.averagePrice = stats.totalPrice / stats.bookCount;
    }
    
    return result;
}

static class AuthorStats {
    int bookCount;
    int totalPages;
    double totalPrice;
    double averagePrice;
    int firstBookYear;
    Set<String> genres = new HashSet<>();
}

public Map<String, AuthorStats> calculateAuthorStatsStep1(List<Book> books, int minYear) {
    Map<String, AuthorStats> result = new HashMap<>();
    
    books.stream().forEach(book -> {  // Заменили for-each на forEach
        // ... весь прежний код без изменений ...
    });
    
    // пост-обработка
    result.values().forEach(stats -> 
        stats.averagePrice = stats.totalPrice / stats.bookCount
    );
    
    return result;
}

public Map<String, AuthorStats> calculateAuthorStatsStep2(List<Book> books, int minYear) {
    Map<String, AuthorStats> result = new HashMap<>();
    
    books.stream()
        .filter(book -> book.getYear() >= minYear)           // было: if (year < minYear) continue
        .filter(book -> !book.getGenres().isEmpty())         // было: if (genres.isEmpty()) continue
        .filter(book -> {                                    // было: if (price == null || price <= 0) continue
            Double price = book.getPrice();
            return price != null && price > 0;
        })
        .forEach(book -> {
            // ... урезанный цикл без фильтров ...
            String author = book.getAuthor();
            AuthorStats stats = result.computeIfAbsent(author, k -> {
                AuthorStats s = new AuthorStats();
                s.firstBookYear = book.getYear();
                return s;
            });
            
            stats.bookCount++;
            stats.totalPages += book.getPages();
            stats.totalPrice += book.getPrice();
            
            if (book.getYear() < stats.firstBookYear) {
                stats.firstBookYear = book.getYear();
            }
            
            book.getGenres().forEach(genre -> stats.genres.add(genre));
        });
    
    result.values().forEach(stats -> 
        stats.averagePrice = stats.totalPrice / stats.bookCount
    );
    
    return result;
}

// Вспомогательный record для промежуточных данных
record BookData(String author, int year, int pages, double price, List<String> genres) {}

public Map<String, AuthorStats> calculateAuthorStatsStep3(List<Book> books, int minYear) {
    Map<String, List<BookData>> grouped = books.stream()
        .filter(book -> book.getYear() >= minYear)
        .filter(book -> !book.getGenres().isEmpty())
        .filter(book -> book.getPrice() != null && book.getPrice() > 0)
        .map(book -> new BookData(
            book.getAuthor(),
            book.getYear(),
            book.getPages(),
            book.getPrice(),
            book.getGenres()
        ))
        .collect(Collectors.groupingBy(BookData::author));
    
    // Отдельный проход для агрегации
    Map<String, AuthorStats> result = new HashMap<>();
    grouped.forEach((author, dataList) -> {
        AuthorStats stats = new AuthorStats();
        stats.bookCount = dataList.size();
        stats.totalPages = dataList.stream().mapToInt(BookData::pages).sum();
        stats.totalPrice = dataList.stream().mapToDouble(BookData::price).sum();
        stats.averagePrice = stats.totalPrice / stats.bookCount;
        stats.firstBookYear = dataList.stream()
            .mapToInt(BookData::year)
            .min()
            .orElse(0);
        stats.genres = dataList.stream()
            .flatMap(d -> d.genres().stream())
            .collect(Collectors.toSet());
        
        result.put(author, stats);
    });
    
    return result;
}

public Map<String, AuthorStats> calculateAuthorStatsStep4(List<Book> books, int minYear) {
    return books.stream()
        .filter(book -> book.getYear() >= minYear)
        .filter(book -> !book.getGenres().isEmpty())
        .filter(book -> book.getPrice() != null && book.getPrice() > 0)
        .collect(Collectors.groupingBy(
            Book::getAuthor,
            Collector.of(
                AuthorStats::new,           // supplier
                (stats, book) -> {          // accumulator
                    if (stats.bookCount == 0) {
                        stats.firstBookYear = book.getYear();
                    } else {
                        stats.firstBookYear = Math.min(stats.firstBookYear, book.getYear());
                    }
                    stats.bookCount++;
                    stats.totalPages += book.getPages();
                    stats.totalPrice += book.getPrice();
                    stats.genres.addAll(book.getGenres());
                },
                (left, right) -> {          // combiner для parallelStream
                    if (left.bookCount == 0) return right;
                    if (right.bookCount == 0) return left;
                    
                    AuthorStats merged = new AuthorStats();
                    merged.bookCount = left.bookCount + right.bookCount;
                    merged.totalPages = left.totalPages + right.totalPages;
                    merged.totalPrice = left.totalPrice + right.totalPrice;
                    merged.firstBookYear = Math.min(left.firstBookYear, right.firstBookYear);
                    merged.genres.addAll(left.genres);
                    merged.genres.addAll(right.genres);
                    return merged;
                },
                stats -> {                  // finisher
                    stats.averagePrice = stats.totalPrice / stats.bookCount;
                    return stats;
                }
            )
        ));
}

public Map<String, AuthorStats> calculateAuthorStatsPragmatic(List<Book> books, int minYear) {
    // Предварительная фильтрация — ясная и тестируемая
    List<Book> validBooks = books.stream()
        .filter(this::isValidForStats)
        .filter(book -> book.getYear() >= minYear)
        .collect(Collectors.toList());
    
    // Группировка — стандартная операция
    Map<String, List<Book>> byAuthor = validBooks.stream()
        .collect(Collectors.groupingBy(Book::getAuthor));
    
    // Агрегация — явный цикл с понятной логикой
    Map<String, AuthorStats> result = new HashMap<>();
    for (Map.Entry<String, List<Book>> entry : byAuthor.entrySet()) {
        result.put(entry.getKey(), aggregateStats(entry.getValue()));
    }
    
    return result;
}

private boolean isValidForStats(Book book) {
    return !book.getGenres().isEmpty() 
        && book.getPrice() != null 
        && book.getPrice() > 0;
}

private AuthorStats aggregateStats(List<Book> authorBooks) {
    AuthorStats stats = new AuthorStats();
    stats.bookCount = authorBooks.size();
    stats.totalPages = authorBooks.stream()
        .mapToInt(Book::getPages)
        .sum();
    stats.totalPrice = authorBooks.stream()
        .mapToDouble(Book::getPrice)
        .sum();
    stats.averagePrice = stats.totalPrice / stats.bookCount;
    stats.firstBookYear = authorBooks.stream()
        .mapToInt(Book::getYear)
        .min()
        .orElse(0);
    stats.genres = authorBooks.stream()
        .flatMap(b -> b.getGenres().stream())
        .collect(Collectors.toSet());
    return stats;
}

// Опасно: параллельный stream с непотокобезопасным accumulators
.collect(Collectors.groupingByConcurrent(
    Book::getAuthor,
    Collector.of(
        () -> new AuthorStats(),  // ОК — новый для каждого
        (stats, book) -> stats.genres.addAll(...),  // Опасно! HashSet не thread-safe
        ...
    )
))

public class Task310326 {
    public static void main(String[] args) {
        int[] arr = new int[2];
        System.out.println(arr + arr);
        System.out.println(arr == arr);
        System.out.println(arr.equals(arr));
        System.out.println(arr.hashCode() == arr.hashCode());
    }
}

import java.util.concurrent.ConcurrentHashMap;

public class StringInternRisk {
    
    //Антипаттерн: интернирование всех строк
    public static String dangerousIntern(String value) {
        return value.intern(); // Попадает в Metaspace, никогда не освободится
    }
    
    //Решение: ручной пул с контролем
    private static final ConcurrentHashMap<String, String> STRING_POOL = new ConcurrentHashMap<>();
    
    public static String safeDeduplicate(String value) {
        // putIfAbsent атомарно добавляет, если отсутствует
        String existing = STRING_POOL.putIfAbsent(value, value);
        return existing != null ? existing : value;
    }
    
    // Вариант с автоматической очисткой через WeakReference
    private static final ConcurrentHashMap<String, WeakReference<String>> WEAK_POOL = new ConcurrentHashMap<>();
       
    // Для ограниченных наборов — enum
    public enum Status {
        NEW, PROCESSING, COMPLETED;
        // вместо "NEW".intern() используйте Status.NEW.name()
    }
    
    public static void main(String[] args) {
        String s1 = new String("Hello");
        String s2 = new String("Hello");
        
        // Рискованно
        String interned = s1.intern();
        System.out.println(s1 == s2); // false
        System.out.println(s1 == interned); // true (попал в пул)
        
        // Безопасная альтернатива
        String dedup = safeDeduplicate(s2);
        System.out.println(s1 == dedup); // false, но equals true — корректно
        
        // Демонстрация утечки: цикл с уникальными строками быстро заполнит Metaspace
        for (int i = 0; i < 1_000_000; i++) {
            String unique = Integer.toString(i);
            // unique.intern(); // Раскомментировать — опасно, приведет к OOM
        }
    }
}

import java.util.ArrayList;
import java.util.List;

public class Task010426 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        
        for (int i = 0; i < 10_000; i++) {
            String s = new String("data_" + i);
            String interned = s.intern();
            list.add(interned);
        }
        
        String a = new String("data_5000");
        String b = a.intern();
        
        System.out.println(a == b);
        System.out.println(a == list.get(5000));
        System.out.println(b == list.get(5000));
    }
}

// Натуральные числа: 0, 1, 2, 3...
Stream<Integer> natural = Stream.iterate(0, n -> n + 1);

// Степени двойки: 1, 2, 4, 8...
Stream<Integer> powersOfTwo = Stream.iterate(1, n -> n * 2);

// Фибоначчи: пара (a, b) -> (b, a+b)
Stream<long[]> fibonacci = Stream.iterate(
    new long[]{0, 1}, 
    f -> new long[]{f[1], f[0] + f[1]}
);

// Числа от 0 до 99
Stream<Integer> limited = Stream.iterate(
    0,           // seed
    n -> n < 100, // hasNext (предикат продолжения)
    n -> n + 1    // next (функция следующего)
);

// Постоянное значение
Stream<String> constants = Stream.generate(() -> "repeat");

// Случайные числа
Stream<Double> randoms = Stream.generate(Math::random);

// Уникальные ID через атомарный счётчик
AtomicLong idGenerator = new AtomicLong(0);
Stream<String> uniqueIds = Stream.generate(() -> "ID-" + idGenerator.incrementAndGet());

// Сортированный поток температур
IntStream temperatures = IntStream.of(15, 18, 22, 25, 19, 12, 8);

// takeWhile: температура ниже 25
temperatures.takeWhile(t -> t < 25)
    .forEach(System.out::println);  // 15, 18, 22 — остановка на 25

// dropWhile: пропускаем прохладную погоду
temperatures.dropWhile(t -> t < 20)
    .forEach(System.out::println);  // 22, 25, 19, 12, 8

// Бесконечная последовательность, ограниченная условием
Stream.iterate(1, n -> n * 2)
    .takeWhile(n -> n < 1000)  // 1, 2, 4, 8, ..., 512 — остановка
    .forEach(System.out::println);