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());                // собрать в список

import java.util.stream.Stream;

public class Task200226 {
    public static void main(String[] args) {
        Stream.of(1, 2, 3, 4, 5)
            .filter(i -> {
                System.out.print(i + " ");
                return i % 2 == 0;
            })
            .map(i -> i * 10)
            .findFirst()
            .ifPresent(i -> System.out.print("result: " + i));
    }
}