List<Book> arrayList = new ArrayList<>(largeLibrary);
List<Book> linkedList = new LinkedList<>(largeLibrary);

// ArrayList — хорошее разбиение
long arrayListParallel = measure(() -> 
    arrayList.parallelStream().filter(...).collect(...));

// LinkedList — плохое разбиение
long linkedListParallel = measure(() ->
    linkedList.parallelStream().filter(...).collect(...));

System.out.println("ArrayList parallel: " + arrayListParallel + " мс");
System.out.println("LinkedList parallel: " + linkedListParallel + " мс");

public Map<String, Double> analyzeGenreComplexityParallel() {
    return books.parallelStream()
        .collect(Collectors.groupingByConcurrent(
            book -> book.getGenres().get(0),  // основной жанр
            Collectors.averagingInt(Book::getComplexity)
        ));
}

import java.util.*;

public class Task230326 {
    public static void main(String[] args) {
        TreeSet<String> set = new TreeSet<>();
        set.add("apple");
        set.add("banana");
        System.out.println(set.contains(null));
    }
}

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.*;

public class LambdaCaptureExample {
    
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        
        //Ошибка: переменная не effectively final
        int count = 0;
        // names.forEach(name -> count++); // Compilation error!
        
        //Ошибка: передача изменяемой переменной
        int threshold = 5;
        // threshold = 10;
        // names.stream().filter(name -> name.length() > threshold); // Ошибка! threshold изменился
        
        //Решение 1: AtomicInteger для счетчика
        AtomicInteger counter = new AtomicInteger(0);
        names.forEach(name -> {
            if (name.length() > 3) {
                counter.incrementAndGet(); // Безопасно
            }
        });
        System.out.println("Count > 3: " + counter.get());
        
        //Решение 2: Использование Stream API вместо накопления
        long streamCount = names.stream()
            .filter(name -> name.length() > 3)
            .count(); // Никаких захваченных переменных
        System.out.println("Stream count: " + streamCount);
        
        //Решение 3: Массив как контейнер
        int[] arrayCount = {0};
        names.forEach(name -> {
            if (name.length() > 3) {
                arrayCount[0]++; // Работает, но менее элегантно
            }
        });
        System.out.println("Array count: " + arrayCount[0]);
                
        //Антипаттерн: сложный захват
        for (int i = 0; i < 3; i++) {
            // i меняется, нельзя использовать в лямбде
            // new Thread(() -> System.out.println(i)).start(); // Ошибка!
            
            //Правильно: копия значения
            int index = i;
            new Thread(() -> System.out.println("Index: " + index)).start();
        }
        
        // Пример с effectively final
        String prefix = "User: "; // effectively final
        names.stream()
            .map(name -> prefix + name) // Работает
            .forEach(System.out::println);
        
        // prefix = "Person: "; // Раскомментируй — ошибка!
    }
}

import java.util.function.Consumer;

public class Task240326 {
    public static void main(String[] args) {
        int[] counter = {0};
        
        Consumer<String> processor = s -> {
            counter[0]++;
            System.out.print(s + counter[0] + " ");
        };
        
        for (int i = 0; i < 3; i++) {
            processor.accept("A");
        }
        
        System.out.println(counter[0]);
    }
}

// Индексы для обхода: 0, 1, 2, ..., 99
IntStream indices = IntStream.range(0, 100);

// Дни месяца: 1, 2, ..., 31
IntStream days = IntStream.rangeClosed(1, 31);

// Степени двойки: 1, 2, 4, 8, ... с ограничением
IntStream powersOfTwo = IntStream.iterate(1, n -> n * 2)
    .limit(20);

// Случайные числа
IntStream randomInts = new Random().ints();  // Бесконечный
IntStream limitedRandom = new Random().ints(100, 0, 1000);  // 100 чисел от 0 до 999

int sum = IntStream.range(1, 101).sum();  // 5050, возвращает int

long count = LongStream.range(0, 1_000_000).count();  // 1000000L

OptionalDouble average = IntStream.of(10, 20, 30).average();  // OptionalDouble[20.0]

OptionalInt max = IntStream.of(3, 1, 4, 1, 5).max();  // OptionalInt[5]
OptionalInt, OptionalLong, OptionalDouble — примитивные версии Optional, избегающие обёртки. Методы: isPresent(), getAsInt() / getAsLong() / getAsDouble(), orElse(int), orElseGet(IntSupplier).

IntSummaryStatistics stats = IntStream.of(10, 20, 30, 40, 50)
    .summaryStatistics();

System.out.println(stats.getCount());    // 5
System.out.println(stats.getSum());      // 150
System.out.println(stats.getMin());      // 10
System.out.println(stats.getMax());      // 50
System.out.println(stats.getAverage());  // 30.0

Stream<Integer> boxed = IntStream.range(0, 100).boxed();

// Применение сложных операций, недоступных для примитивов
List<String> labels = IntStream.range(0, 100)
    .boxed()
    .map(i -> "Item #" + i)
    .collect(toList());

List<Book> booksByIndex = IntStream.range(0, library.size())
    .mapToObj(i -> new Book("Book " + i, "Author " + i, 2000 + i))
    .collect(toList());
mapToObj(IntFunction<R>) принимает функцию, создающую объект из индекса, без промежуточного boxed().
mapToInt, mapToLong, mapToDouble: объект к примитиву

// Суммарное количество страниц
int totalPages = library.stream()
    .mapToInt(Book::pageCount)  // Book -> int
    .sum();

// Средняя цена в long-центах для точности
long averagePriceCents = library.stream()
    .mapToLong(b -> b.price().multiply(BigDecimal.valueOf(100)).longValue())
    .average()
    .orElse(0L);

// Нумерация элементов с сохранением порядка
List<String> numbered = IntStream.range(0, books.size())
    .mapToObj(i -> (i + 1) + ". " + books.get(i).title())
    .collect(toList());

// Поиск с индексом
OptionalInt firstExpensiveIndex = IntStream.range(0, books.size())
    .filter(i -> books.get(i).price().compareTo(THRESHOLD) > 0)
    .findFirst();  // Возвращает индекс, не объект

// Обобщённый подход для любого Stream
Stream<IndexedValue<Book>> withIndex = StreamUtils.zipWithIndex(books.stream());

// Или через AtomicInteger (менее элегантно, но без внешних библиотек)
AtomicInteger index = new AtomicInteger(0);
List<String> numbered = books.stream()
    .map(b -> index.getAndIncrement() + ": " + b.title())
    .collect(toList());  // Не параллелизуемо!

// Корреляция двух наборов данных (упрощённо)
double[] x = fetchDataX();
double[] y = fetchDataY();

double meanX = Arrays.stream(x).average().orElse(0.0);
double meanY = Arrays.stream(y).average().orElse(0.0);

double covariance = IntStream.range(0, x.length)
    .mapToDouble(i -> (x[i] - meanX) * (y[i] - meanY))
    .average()
    .orElse(0.0);
Arrays.stream(double[]) создаёт DoubleStream без копирования массива — эффективный доступ к существующим данным.

// Эффективная параллельная агрегация
long sum = LongStream.range(0, 100_000_000)
    .parallel()
    .sum();  // Разделение по сегментам, локальные суммы, финальное слияние

import java.util.stream.IntStream;

public class Task250326 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        
        double avg = IntStream.of(arr)
            .map(i -> i % 2 == 0 ? i : 0)
            .average()
            .orElse(0);
            
        System.out.println(avg);
        
        int sum = IntStream.of(arr)
            .map(i -> i % 2 == 0 ? i : 0)
            .sum();
            
        System.out.println(sum);
        
        long count = IntStream.of(arr)
            .map(i -> i % 2 == 0 ? i : 0)
            .count();
            
        System.out.println(count);
    }
}

public class SwitchEnumExample {
    
    public enum Status {
        NEW, PROCESSING, COMPLETED, CANCELLED
    }
    
    //Антипаттерн: switch с default
    public static String badSwitch(Status status) {
        switch (status) { // Обрабатывает не все значения
            case NEW:
                return "Новый";
            case PROCESSING:
                return "В обработке";
            default:
                return "Завершен или отменен"; // CANCELLED попадает сюда незаметно
        }
    }
    
    //Еще хуже: без default
    public static String worseSwitch(Status status) {
        switch (status) {
            case NEW:
                return "Новый";
            case PROCESSING:
                return "В обработке";
            case COMPLETED:
                return "Завершен";
            // CANCELLED не обработан — при его передаче NPE (switch без результата)
        }
        return null;
    }
    
    //Решение 1: Switch-выражение (Java 14+)
    public static String goodSwitch(Status status) {
        return switch (status) {
            case NEW -> "Новый";
            case PROCESSING -> "В обработке";
            case COMPLETED -> "Завершен";
            case CANCELLED -> "Отменен";
            // Компилятор проверит, что все варианты покрыты
        };
    }
    
    //Решение 2: Switch-выражение с блоком
    public static String goodSwitchWithBlock(Status status) {
        return switch (status) {
            case NEW -> "Новый";
            case PROCESSING -> "В обработке";
            case COMPLETED -> {
                String msg = "Завершен";
                yield msg; // yield вместо return в блоке
            }
            case CANCELLED -> "Отменен";
        };
    }
        
    // Теперь добавление нового элемента enum требует переопределения метода
    // — компилятор принуждает к этому
    
    public static void main(String[] args) {
        System.out.println(goodSwitch(Status.NEW));
        System.out.println(goodSwitch(Status.CANCELLED));
        
        System.out.println(StatusWithMethod.COMPLETED.getDisplayName());
        
        // Демонстрация проблемы
        System.out.println(badSwitch(Status.CANCELLED)); // "Завершен или отменен" — потеря информации
     }
}

public class Task260326 {
    enum Level {
        LOW, MEDIUM, HIGH
    }
    
    public static void main(String[] args) {
        Level level = Level.valueOf("HIGH");
        String result = getPriority260326(level);
        System.out.println(result);
    }
    
    static String getPriority260326(Level level) {
        switch (level) {
            case LOW:
                return "Low priority";
            case MEDIUM:
                return "Medium priority";
        }
        return "Unknown";
    }
}