package com.example.model;

public enum OrderStatus {
    NEW("Новый") {
        @Override
        public void handle() {
            System.out.println("Проверка наличия товара для нового заказа");
        }
    },
    PROCESSING("В обработке") {
        @Override
        public void handle() {
            System.out.println("Передача в службу доставки");
        }
    },
    COMPLETED("Завершен") {
        @Override
        public void handle() {
            System.out.println("Отправка опроса удовлетворенности");
        }
    };

    private final String displayName;

    OrderStatus(String displayName) {
        this.displayName = displayName;
    }

    public String getDisplayName() { 
        return displayName; 
    }

    public abstract void handle();
}

// OrderService.java - Сервисный слой
package com.example.service;

import com.example.model.OrderStatus;

public class OrderService {
    
    public void processOrder(OrderStatus status) {
        if (status == null) {
            throw new IllegalArgumentException("Статус не может быть null");
        }
        
        status.handle();
        displayStatusInfo(status);
    }
    
    private void displayStatusInfo(OrderStatus status) {
        switch (status) {
            case NEW -> System.out.println("Отображение как: " + status.getDisplayName());
            case PROCESSING -> System.out.println("Отображение как: " + status.getDisplayName());
            case COMPLETED -> System.out.println("Отображение как: " + status.getDisplayName());
        }
    }
}

// Application.java - Точка входа
package com.example;

import com.example.model.OrderStatus;
import com.example.service.OrderService;

public class Application {
    public static void main(String[] args) {
        OrderService orderService = new OrderService();
        orderService.processOrder(OrderStatus.NEW);
    }
}

public class Task170226 {
    enum Color {
        RED, GREEN, BLUE;
        
        static {
            System.out.println("Static block");
        }
        
        Color() {
            System.out.println("Constructor: " + this);
        }
    }
    
    public static void main(String[] args) {
        System.out.println("Start");
        Color c = Color.RED;
        System.out.println("End");
    }
}

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))
    .map(i -> i * i)
    .peek(i -> System.out.println("mapped: " + i))

OptionalInt result = IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))
    .map(i -> i * i)
    .peek(i -> System.out.println("mapped: " + i))
    .findFirst();

source: 0
filtered: 0
mapped: 0
Почему только одна цепочка? Потому что findFirst() — короткозамкнутая операция. Как только найден первый подходящий элемент (0), выполнение останавливается. Остальные числа от 1 до 9 даже не достигают источника.

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))
    .map(i -> i * i)
    .peek(i -> System.out.println("mapped: " + i))
    .forEach(i -> System.out.println("result: " + i));

source: 0
filtered: 0
mapped: 0
result: 0
source: 1
source: 2
filtered: 2
mapped: 4
result: 4
source: 3
source: 4
filtered: 4
mapped: 16
result: 16
...

Элемент 0: source → filter → map → result
Элемент 1: source → (отфильтрован) → ...
Элемент 2: source → filter → map → result

Все source: 0,1,2,3,4,5,6,7,8,9
Все filtered: 0,2,4,6,8
Все mapped: 0,4,16,36,64

// Создаём полный список, сортируем, берём первый
List<Book> filtered = new ArrayList<>();
for (Book b : books) {
    if (b.getAuthor().equals("X")) {
        filtered.add(b);
    }
}
filtered.sort(Comparator.comparingInt(Book::getYear));
Book first = filtered.get(0);  // Всё равно обработали все книги

Optional<Book> first = books.stream()
    .filter(b -> b.getAuthor().equals("X"))
    .sorted(Comparator.comparingInt(Book::getYear))
    .findFirst();  // Остановится при первой найденной книге

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .map(i -> i * i)           // теперь раньше
    .peek(i -> System.out.println("mapped: " + i))
    .filter(i -> i % 2 == 0)   // теперь позже
    .peek(i -> System.out.println("filtered: " + i))
    .forEach(i -> System.out.println("result: " + i));

IntStream.range(0, 1000)  // большой диапазон
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))
    .limit(3)
    .forEach(i -> System.out.println("result: " + i));

import java.util.Arrays;

public class Task180226 {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        int[] arr3 = arr1;

        arr3[0] = 10;

        System.out.println(arr1 == arr2);
        System.out.println(arr1.equals(arr2));
        System.out.println(Arrays.equals(arr1, arr2));
        System.out.println(arr1[0] + " " + arr2[0] + " " + arr3[0]);
    }
}

import java.util.concurrent.TimeUnit;

public class PerformanceMeasurement {
    public static void main(String[] args) throws InterruptedException {
        //Антипаттерн: Измерение через currentTimeMillis()
        long startMillis = System.currentTimeMillis();
        
        // Имитация работы
        Thread.sleep(100);
        
        long endMillis = System.currentTimeMillis();
        long durationMillis = endMillis - startMillis;
        System.out.println("currentTimeMillis() duration: " + durationMillis + " ms");
        
        // Проблема: если во время замера часы переведятся назад,
        // duration может быть отрицательным или неточным.

        //Решение: Измерение через nanoTime()
        long startNanos = System.nanoTime();
        
        // Имитация работы
        Thread.sleep(100);
        
        long endNanos = System.nanoTime();
        long durationNanos = endNanos - startNanos;
        
        // Конвертация в миллисекунды для читаемости
        long durationMs = TimeUnit.NANOSECONDS.toMillis(durationNanos);
        double preciseMs = durationNanos / 1_000_000.0;
        
        System.out.println("nanoTime() duration: " + durationNanos + " ns");
        System.out.println("nanoTime() duration (ms): " + durationMs + " ms");
        System.out.println("nanoTime() duration (precise ms): " + preciseMs + " ms");
        
        // Демонстрация для сверхбыстрых операций
        long fastStart = System.nanoTime();
        int sum = 0;
        for (int i = 0; i < 1000; i++) {
            sum += i;
        }
        long fastEnd = System.nanoTime();
        System.out.println("Loop duration: " + (fastEnd - fastStart) + " ns");
        
        // Важно: nanoTime() нельзя использовать для получения времени суток
        // System.out.println(System.nanoTime()); // Бессмысленное огромное число
    }
    
    // Правильный способ измерения среднего времени выполнения
    public static double measureAverageTime(Runnable task, int iterations) {
        // Прогрев JVM (warm-up) для компиляции и оптимизации кода
        for (int i = 0; i < 10_000; i++) {
            task.run();
        }
        
        long totalNanos = 0;
        for (int i = 0; i < iterations; i++) {
            long start = System.nanoTime();
            task.run();
            long end = System.nanoTime();
            totalNanos += (end - start);
        }
        
        return (double) totalNanos / iterations;
    }
}

package oleborn.taskswithspring.tasks.year2026;

public class Task190226 {
    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(5);
        long end = System.currentTimeMillis();

        long startNano = System.nanoTime();
        Thread.sleep(5);
        long endNano = System.nanoTime();

        System.out.println("Millis diff: " + (end - start));
        System.out.println("Nanos diff in ms: " + (endNano - startNano) / 1_000_000);
    }
}

Stream<Book> classics = library.stream()
    .filter(book -> book.year() < 1980);

// Антипаттерн: предикат с побочным эффектом
AtomicInteger counter = new AtomicInteger(0);
Stream<Book> everyThird = library.stream()
    .filter(b -> counter.incrementAndGet() % 3 == 0);  // Недетерминировано при parallel()

Stream<String> titles = library.stream()
    .map(Book::title);

Stream<Integer> lengths = titles.map(String::length);

// Цепочка преобразований: Book -> String -> Integer -> String
String summary = book.stream()
    .map(Book::author)           // Book -> String
    .map(String::toUpperCase)    // String -> String
    .map(author -> author.substring(0, 3))  // String -> String
    .map(prefix -> "Author: " + prefix)     // String -> String
    .findFirst()
    .orElse("Unknown");

List<Order> orders = fetchOrders();

// Императивный подход: вложенные циклы, временная коллекция
List<OrderItem> allItems = new ArrayList<>();
for (Order order : orders) {
    for (OrderItem item : order.getItems()) {
        allItems.add(item);
    }
}

// Декларативный подход: flatMap
Stream<OrderItem> itemStream = orders.stream()
    .flatMap(order -> order.getItems().stream());

// Фильтрация через flatMap: ноль или один элемент
Stream<Book> validBooks = rawData.stream()
    .flatMap(data -> {
        try {
            Book book = parseBook(data);  // Может бросить исключение
            return Stream.of(book);         // Один элемент при успехе
        } catch (ParseException e) {
            return Stream.empty();          // Ноль элементов при ошибке
        }
    });

// Антипаттерн: глубокая вложенность flatMap
Stream<String> deepStream = orders.stream()
    .flatMap(order -> order.getShipments().stream()
        .flatMap(shipment -> shipment.getPackages().stream()
            .flatMap(pkg -> pkg.getItems().stream()
                .flatMap(item -> item.getTags().stream()))));

// Лучше: именованные методы с ясной семантикой
Stream<String> tags = orders.stream()
    .flatMap(this::extractShipments)
    .flatMap(this::extractPackages)
    .flatMap(this::extractItems)
    .flatMap(this::extractTags);

private Stream<Shipment> extractShipments(Order order) {
    return order.getShipments().stream();
}
// ... и так далее

// mapMulti: более эффективен, чем flatMap, для множественных элементов
Stream<String> tags = orders.stream()
    .<String>mapMulti((order, consumer) -> {
        for (Shipment s : order.getShipments()) {
            for (Package p : s.getPackages()) {
                for (Item i : p.getItems()) {
                    for (String tag : i.getTags()) {
                        consumer.accept(tag);  // Прямая передача без создания Stream
                    }
                }
            }
        }
    });

// "Найти все уникальные теги из активных заказов, отсортированные по алфавиту"
List<String> sortedUniqueTags = orders.stream()
    .filter(Order::isActive)           // которые активны
    .flatMap(o -> o.getTags().stream()) // извлечь все теги
    .distinct()                        // уникальные
    .sorted()                          // отсортированные
    .collect(toList());                // собрать в список