// O(n × m × k) — полиномиальная сложность
List<Review> allRecentReviews = new ArrayList<>();

for (Category category : categories) {
    for (Product product : category.getProducts()) {
        for (Review review : product.getReviews()) {
            if (review.getDate().isAfter(lastMonth)) {
                allRecentReviews.add(review);
            }
        }
    }
}

public List<Order> getTopThreeOptimized(List<Order> orders) {
    // Очередь с обратным порядком (минимальная сумма на вершине)
    PriorityQueue<Order> minHeap = new PriorityQueue<>(
        Comparator.comparing(Order::getAmount)
    );
    
    for (Order order : orders) {
        if (order.getStatus() == Status.COMPLETED) {
            if (minHeap.size() < 3) {
                minHeap.offer(order);
            } else if (order.getAmount().compareTo(minHeap.peek().getAmount()) > 0) {
                minHeap.poll();  // Удаляем минимальный из топ-3
                minHeap.offer(order);
            }
        }
    }
    
    // Преобразование в список и сортировка по убыванию
    List<Order> result = new ArrayList<>(minHeap);
    result.sort(Comparator.comparing(Order::getAmount).reversed());
    return result;
}

for (Item item : items) {
    if (complexValidation(item)) {
        processFoundItem(item);   // Постобработка
        return result;            // Мгновенный выход из метода
    }
}

public class Task040226 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int i = 0;
        arr[i] = i = 2;
        System.out.println(arr[0] + " " + arr[2]);
    }
}

public class StringConcatExample {
    public static void main(String[] args) {
        String[] words = {"Это", "пример", "неэффективной", "конкатенации"};

        //Антипаттерн: Каждый "+" создает новый String-объект.
        String badResult = "";
        for (String word : words) {
            badResult = badResult + word + " "; // Новый объект на каждом шаге!
        }
        System.out.println(badResult);

        //Решение: Использование StringBuilder.
        StringBuilder sb = new StringBuilder(); // Можно задать начальную capacity для оптимизации.
        for (String word : words) {
            sb.append(word).append(" "); // Работа с внутренним буфером.
        }
        String goodResult = sb.toString().trim(); // Создание финального String происходит лишь один раз.
        System.out.println(goodResult);

        // Для простого однострочного соединения коллекций предпочтительнее String.join()
        String bestResult = String.join(" ", words); // Читаемо и эффективно.
        System.out.println(bestResult);
    }
}

public class Task050226 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("12345");
        
        sb.delete(2, 4);
        sb.insert(2, "xyz");
        sb.replace(1, 3, "ab");
        
        System.out.println(sb);
    }
}

public List<Order> getTopThreeCompletedOrders(List<Order> orders) {
    return orders.stream()
        .filter(order -> order.getStatus() == Status.COMPLETED)  // Что: отфильтровать выполненные
        .sorted(Comparator.comparing(Order::getAmount).reversed())  // Что: упорядочить по убыванию
        .limit(3)  // Что: взять первые три
        .collect(Collectors.toList());  // Как собрать — стратегия терминальной операции
}

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