Stream<Order> stream = orders.stream()
    .filter(order -> {
        System.out.println("Фильтрация: " + order.getId());
        return order.getStatus() == Status.COMPLETED;
    })
    .map(order -> {
        System.out.println("Маппинг: " + order.getId());
        return order.calculateFinalAmount();
    });

// На этом этапе ничего не напечатано — построен только чертёж
System.out.println("Конвейер построен");

List<BigDecimal> amounts = stream.limit(3).collect(Collectors.toList());
// Только сейчас начинается выполнение, и оно остановится после 3 подходящих элементов

// Упрощённая логика toList() внутри — мы описываем, а не исполняем
Collector<T, ?, List<T>> toListCollector = Collector.of(
    ArrayList::new,           // Supplier: создаём пустой список (начальное состояние)
    List::add,                // Accumulator: добавляем элемент (переход состояния)
    (left, right) -> {        // Combiner: объединяем два состояния при параллелизме
        left.addAll(right);
        return left;
    }
);

List<BigDecimal> result = orders.parallelStream()  // Или .stream().parallel()
    .filter(order -> complexValidation(order))      // Выполняется в разных потоках
    .map(Order::calculateFinalAmount)
    .collect(Collectors.toList());

// В цикле создаём стримы — порождаем множество объектов
for (List<Record> batch : batches) {
    batch.stream()
        .filter(r -> r.isActive())
        .map(r -> transform(r))
        .collect(Collectors.toList());
    // Все объекты Pipeline здесь становятся мусором
}

java.lang.NullPointerException
    at com.example.Service.lambda$process$0(Service.java:25)
    at java.base/java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:178)
    at java.base/java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1625)
    at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
    at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
    at java.base/java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:921)
    at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.base/java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:682)
    at com.example.Service.process(Service.java:26)

// Императивно: можем обработать ошибку элемента и продолжить
List<Result> results = new ArrayList<>();
for (Record record : records) {
    try {
        Result r = process(record);
        if (r.isValid()) {
            results.add(r);
        }
    } catch (ProcessingException e) {
        log.warn("Пропускаем запись {}: {}", record.getId(), e.getMessage());
        // Продолжаем цикл
    }
}

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Task060226 {
    public static void main(String[] args) {
        String result = Stream.of("a", "b", "c", "d")
            .collect(Collectors.collectingAndThen(
                Collectors.joining("+"),
                    String::toUpperCase
            ));
        
        System.out.println(result);
    }
}

import java.math.BigDecimal;
import java.math.RoundingMode;

public class MonetaryCalculation {
    public static void main(String[] args) {
        //Антипаттерн: Ошибка округления.
        double dollars = 1.00;
        double centsToAdd = 0.10;
        for (int i = 0; i < 10; i++) {
            dollars += centsToAdd; // Приблизительное вычисление
        }
        System.out.println("Double result: " + dollars); // Выведет ~2.0999999999999996

        //Решение 1: Использование BigDecimal (с конструктором из String!).
        BigDecimal bigDollars = new BigDecimal("1.00");
        BigDecimal bigCents = new BigDecimal("0.10");
        for (int i = 0; i < 10; i++) {
            bigDollars = bigDollars.add(bigCents); // Точное вычисление
        }
        System.out.println("BigDecimal result: " + bigDollars); // Точно 2.00

        // Важно: Задание масштаба и режима округления для операций.
        BigDecimal a = new BigDecimal("10.00");
        BigDecimal b = new BigDecimal("3.00");
        BigDecimal division = a.divide(b, 2, RoundingMode.HALF_UP); // 3.33
        System.out.println("Division with rounding: " + division);

        //Решение 2: Использование целых чисел (в копейках).
        long balanceInKopecks = 100L; // 1 рубль = 100 копеек
        long kopecksToAdd = 10L; // 10 копеек
        for (int i = 0; i < 10; i++) {
            balanceInKopecks += kopecksToAdd;
        }
        double resultInRubles = balanceInKopecks / 100.0; // Преобразование для вывода
        System.out.println("Long (kopecks) result: " + resultInRubles); // Точно 2.0
    }
}

public class Task090226 {
    public static void main(String[] args) {
        double price = 0.10;
        double total = 0.00;
        int items = 0;
        
        for (int i = 0; i < 10; i++) {
            total += price;
        }
        
        System.out.println(total == 1.00);
        System.out.println(total);
    }
}