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