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