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

// UUID с проверкой уникальности в пределах сессии
Set<String> usedIds = ConcurrentHashMap.newKeySet();
Stream<String> uniqueIds = Stream.generate(UUID::randomUUID)
    .map(UUID::toString)
    .filter(usedIds::add)  // add возвращает false если уже есть, фильтруем дубликаты
    .limit(1000);          // строго 1000 уникальных

// Или с takeWhile для условной остановки
Stream<String> idsUntilPattern = Stream.generate(this::generateId)
    .takeWhile(id -> !id.contains("STOP"));  // Генерация до спецпаттерна

// Плохо: немедленное создание списка
List<Integer> eager = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
    if (isPrime(i)) eager.add(i);
}

// Хорошо: ленивый поток, элементы вычисляются по требованию
IntStream primes = IntStream.iterate(2, n -> n + 1)
    .filter(this::isPrime)
    .takeWhile(n -> n < 1000000);

// Потребление только первых 10, остальные никогда не вычислены
primes.limit(10).forEach(System.out::println);

import java.util.stream.Stream;

public class Task020426 {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.iterate(0, n -> n + 1)
            .filter(n -> n % 2 == 0)
            .map(n -> {
                System.out.print(n + " ");
                return n;
            })
            .limit(3);
        
        stream.forEach(n -> {});
    }
}

import java.math.BigDecimal;

public class BigDecimalPrecision {
    
    public static void main(String[] args) {
        //Антипаттерн: конструктор от double
        BigDecimal fromDouble = new BigDecimal(0.1);
        System.out.println("new BigDecimal(0.1): " + fromDouble);
        // Вывод: 0.1000000000000000055511151231257827021181583404541015625
        
        //Ошибка в сравнении
        BigDecimal expected = new BigDecimal("0.1");
        System.out.println("Равны? " + fromDouble.equals(expected)); // false!
        
        //Ошибка в арифметике
        BigDecimal sum = new BigDecimal(0.1).add(new BigDecimal(0.2));
        System.out.println("0.1 + 0.2 = " + sum);
        // Вывод: 0.3000000000000000166533453693773481063544750213623046875
        
        //Решение 1: BigDecimal.valueOf(double)
        BigDecimal fromValueOf = BigDecimal.valueOf(0.1);
        System.out.println("BigDecimal.valueOf(0.1): " + fromValueOf); // 0.1
        
        //Решение 2: конструктор от String
        BigDecimal fromString = new BigDecimal("0.1");
        System.out.println("new BigDecimal(\"0.1\"): " + fromString); // 0.1
        
        // Проверка равенства
        System.out.println("valueOf == string: " + fromValueOf.equals(fromString)); // true
        
        //Безопасная арифметика
        BigDecimal safeSum = BigDecimal.valueOf(0.1).add(BigDecimal.valueOf(0.2));
        System.out.println("Безопасная сумма: " + safeSum); // 0.3
        
        // Для целых чисел конструктор от double безопасен
        BigDecimal intValue = new BigDecimal(10.0);
        System.out.println("Целое число: " + intValue); // 10
    }
}

import java.math.BigDecimal;

public class Task030426 {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal(0.1);
        BigDecimal bd2 = BigDecimal.valueOf(0.1);
        BigDecimal bd3 = new BigDecimal("0.1");
        
        System.out.println(bd1.equals(bd2));
        System.out.println(bd1.equals(bd3));
        System.out.println(bd2.equals(bd3));
        System.out.println(bd1.compareTo(bd2));
    }
}