// Индексы для обхода: 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";
    }
}

List<String> names = new ArrayList<>();
Optional<User> optionalUser = userRepository.findById(userId);

if (optionalUser.isPresent()) {
    User user = optionalUser.get();
    names.add(user.name());
}
// names содержит 0 или 1 элемент, логика размазана по условию

List<String> names = userRepository.findById(userId)
    .stream()                    // Optional<User> -> Stream<User> (0 или 1 элемент)
    .map(User::name)             // Stream<String>
    .collect(toList());          // List<String>, размер 0 или 1

// Цепочка: заказ -> клиент -> адрес -> город
List<String> cities = orders.stream()
    .map(Order::getCustomerId)
    .map(customerRepository::findById)     // Stream<Optional<Customer>>
    .flatMap(Optional::stream)             // Stream<Customer>, пустые отфильтрованы
    .map(Customer::getAddress)
    .map(Address::getCity)
    .distinct()
    .collect(toList());

// Найти все заказы пользователя по ID, если пользователь существует
Stream<Order> userOrders = userRepository.findById(userId)
    .stream()                              // Stream<User>
    .flatMap(u -> u.getOrders().stream());  // Stream<Order>

// Сбор в список, если пользователь найден
List<Order> orders = userOrders.collect(toList());

// Было: глубокая вложенность ifPresent
optionalUser.ifPresent(user -> 
    user.getProfile().ifPresent(profile ->
        profile.getAvatar().ifPresent(avatar ->
            process(avatar)
        )
    )
);

// Стало: плоская композиция через stream и flatMap
userRepository.findById(userId)
    .stream()
    .flatMap(u -> u.getProfile().stream())
    .flatMap(p -> p.getAvatar().stream())
    .forEach(this::process);

Optional<Book> oldest = library.stream()
    .filter(b -> b.genre() == Genre.FICTION)
    .min(comparing(Book::year));  // Optional<Book>

// Интеграция обратно в поток
List<String> oldestTitle = oldest
    .stream()                     // Optional -> Stream
    .map(Book::title)
    .collect(toList());

// Репозиторий возвращает Optional<List<Order>> — неудачный дизайн, но встречается
Optional<List<Order>> optionalOrders = orderRepository.findByCustomerId(id);

// Нормализация: Optional<List<Order>> -> Stream<Order>
Stream<Order> orders = optionalOrders
    .stream()                    // Stream<List<Order>>
    .flatMap(List::stream);       // Stream<Order>, пустой если Optional пуст или список пуст

// Или в одном выражении
List<Order> result = optionalOrders.stream()
    .flatMap(List::stream)
    .filter(Order::isActive)
    .collect(toList());

import java.util.*;
import java.util.stream.*;

public class Task270326 {
    public static void main(String[] args) {
        List<Optional<String>> optionals = Arrays.asList(
            Optional.of("java"),
            Optional.empty(),
            Optional.of("kotlin"),
            Optional.empty(),
            Optional.of("scala")
        );
        
        List<String> result = optionals.stream()
            .flatMap(opt -> opt.stream())
            .map(String::toUpperCase)
            .collect(Collectors.toList());
            
        System.out.println(result);
    }
}