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