import java.util.HashSet;

public class Task030226 {
    public static void main(String[] args) {
        HashSet<Item030226> set = new HashSet<>();
        
        Item030226 item1 = new Item030226(1, "apple");
        Item030226 item2 = new Item030226(1, "apple");
        
        set.add(item1);
        item1.id = 2;
        set.add(item2);
        
        System.out.println(set.size());
        System.out.println(set.contains(item1));
        System.out.println(set.contains(item2));
    }
    
    static class Item030226 {
        int id;
        String name;
        
        Item030226(int id, String name) {
            this.id = id;
            this.name = name;
        }
        
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Item030226 item = (Item030226) o;
            return id == item.id && name.equals(item.name);
        }
        
        @Override
        public int hashCode() {
            return id + name.hashCode();
        }
    }
}

public List<Order> getTopThreeCompletedOrders(List<Order> orders) {
    // Инициализация временного состояния
    List<Order> completedOrders = new ArrayList<>();
    
    // Линейный проход с условным накоплением
    for (Order order : orders) {
        if (order.getStatus() == Status.COMPLETED) {
            completedOrders.add(order);
        }
    }
    
    // Сортировка через изменение состояния (in-place или новая коллекция)
    completedOrders.sort((a, b) -> b.getAmount().compareTo(a.getAmount()));
    
    // Извлечение подмножества с проверкой границ
    List<Order> result = new ArrayList<>();
    int limit = Math.min(3, completedOrders.size());
    for (int i = 0; i < limit; i++) {
        result.add(completedOrders.get(i));
    }
    
    return result;
}

// Линейный поиск с ранним выходом
User foundUser = null;
for (User user : users) {
    if (user.getId().equals(targetId)) {
        foundUser = user;  // Нашли — запомнили состояние
        break;             // Прервали ленту — головка остановлена
    }
}

List<Transaction> validTransactions = new ArrayList<>();
BigDecimal totalRisk = BigDecimal.ZERO;

for (Transaction tx : transactions) {
    // Вложенные условия — сложное состояние машины
    if (tx.getAmount().compareTo(THRESHOLD) > 0) {
        if (tx.getTimestamp().isAfter(cutoffDate)) {
            if (!tx.isFlagged()) {
                validTransactions.add(tx);
                totalRisk = totalRisk.add(tx.calculateRisk());
            }
        }
    }
}

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