Какая идеология у flatMap с точки зрения коллекций?

Идеология flatMap: монадическое преобразование с раскрытием коллекций

flatMap — это мощный оператор функционального программирования, реализующий монадическое связывание. Его идеология выходит далеко за пределы простого преобразования элементов.

1. Базовая идея: Map + Flatten

Целое название раскрывает суть: flat + map

map    → применить функцию к каждому элементу
flatten → развернуть вложенные коллекции одним уровнем
flatMap → map + flatten в один проход

List<Integer> numbers = Arrays.asList(1, 2, 3);

// map: каждый элемент → коллекция
List<List<Integer>> mapped = numbers.stream()
  .map(n -> Arrays.asList(n, n*2, n*3))
  .collect(Collectors.toList());
// [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

// flatMap: раскрыть коллекции
List<Integer> flattened = numbers.stream()
  .flatMap(n -> Arrays.asList(n, n*2, n*3).stream())
  .collect(Collectors.toList());
// [1, 2, 3, 2, 4, 6, 3, 6, 9]

2. Монадическое связывание (Monadic Bind)

flatMap реализует операцию bind (>>=) из теории монад:

// Монадический контекст: каждое вычисление может вернуть коллекцию

// Найти все делители чисел
List<Integer> numbers = Arrays.asList(6, 12);

List<Integer> divisors = numbers.stream()
  .flatMap(n -> getDivisors(n).stream())
  .collect(Collectors.toList());
// [1, 2, 3, 6, 1, 2, 3, 4, 6, 12]

private static List<Integer> getDivisors(int n) {
  return IntStream.rangeClosed(1, n)
    .filter(i -> n % i == 0)
    .boxed()
    .collect(Collectors.toList());
}

3. Цепочка преобразований

Прелесть flatMap — возможность цепировать преобразования:

List<String> users = Arrays.asList("Alice", "Bob", "Charlie");

List<String> result = users.stream()
  .flatMap(user -> getUserOrders(user).stream())
  .flatMap(order -> getOrderItems(order).stream())
  .map(item -> item.getName())
  .collect(Collectors.toList());

// Каждый пользователь → его заказы
// Каждый заказ → его товары
// Каждый товар → его имя

4. Раскрытие Optional

flatMap решает проблему вложенных Optional:

// Плохо: вложенные Optional
Optional<User> user = getUser(id);
Optional<Optional<Address>> address = user.map(u -> getAddress(u.getId()));
// Optional<Optional<Address>> — неудобно!

// Хорошо: flatMap раскрывает
Optional<Address> address = user
  .flatMap(u -> getAddress(u.getId()));
// Optional<Address> — чисто!

// Практический пример
Optional<String> city = getUser(1)
  .flatMap(user -> getAddress(user.getId()))
  .flatMap(address -> getCity(address.getCityId()))
  .map(city -> city.toUpperCase());

5. Комбинирование нескольких источников

List<String> names = Arrays.asList("Alice", "Bob");
List<String> cities = Arrays.asList("NYC", "LA", "SF");

// Картезианское произведение: все пары (имя, город)
List<String> pairs = names.stream()
  .flatMap(name -> 
    cities.stream()
      .map(city -> name + " - " + city)
  )
  .collect(Collectors.toList());
// [Alice - NYC, Alice - LA, Alice - SF, Bob - NYC, Bob - LA, Bob - SF]

6. Фильтрация через flatMap

// flatMap может использоваться как фильтр
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Только чётные
List<Integer> evens = numbers.stream()
  .flatMap(n -> n % 2 == 0 ? Stream.of(n) : Stream.empty())
  .collect(Collectors.toList());
// [2, 4]

// Более читаемо с filter
List<Integer> evens = numbers.stream()
  .filter(n -> n % 2 == 0)
  .collect(Collectors.toList());

7. Реальный пример: обработка XML/JSON

// Структура: Person → Addresses → Streets
List<Person> people = getPeople();

List<String> allStreets = people.stream()
  .flatMap(person -> person.getAddresses().stream())
  .flatMap(address -> address.getStreets().stream())
  .map(Street::getName)
  .collect(Collectors.toList());

// Альтернатива с map: требует вложенной итерации
List<String> allStreets = new ArrayList<>();
for (Person person : people) {
  for (Address address : person.getAddresses()) {
    for (Street street : address.getStreets()) {
      allStreets.add(street.getName());
    }
  }
}

8. Производительность

// flatMap создаёт потоки для каждого элемента
List<Integer> numbers = Arrays.asList(1, 2, 3, ..., 1000000);

// Может быть медленнее при огромных коллекциях
List<Integer> result = numbers.parallelStream()
  .flatMap(n -> largeList.stream()) // Создаёт 1M потоков!
  .collect(Collectors.toList());

// Оптимизация для циклов
List<Integer> result = new ArrayList<>();
for (Integer n : numbers) {
  result.addAll(largeList);
}

9. Идеология vs. Императивный стиль

// ФУНКЦИОНАЛЬНЫЙ (декларативный)
public List<String> getUniqueProducts() {
  return orders.stream()
    .flatMap(order -> order.getItems().stream())
    .map(Item::getProductName)
    .distinct()
    .collect(Collectors.toList());
}

// ИМПЕРАТИВНЫЙ (что именно делать)
public List<String> getUniqueProducts() {
  Set<String> unique = new HashSet<>();
  for (Order order : orders) {
    for (Item item : order.getItems()) {
      unique.add(item.getProductName());
    }
  }
  return new ArrayList<>(unique);
}

10. Ошибки при использовании flatMap

// ОШИБКА 1: использовать map вместо flatMap
List<List<Integer>> result = numbers.stream()
  .map(n -> Arrays.asList(n, n*2))  // Неправильно!
  .collect(Collectors.toList());
// Результат: List<List<Integer>> вместо List<Integer>

// ПРАВИЛЬНО
List<Integer> result = numbers.stream()
  .flatMap(n -> Arrays.asList(n, n*2).stream())
  .collect(Collectors.toList());

// ОШИБКА 2: забыть .stream()
List<String> result = names.stream()
  .flatMap(name -> Collections.singletonList(name + "s"))  // Неправильно!
  .collect(Collectors.toList());

// ПРАВИЛЬНО
List<String> result = names.stream()
  .flatMap(name -> Stream.of(name + "s"))  // или .stream()
  .collect(Collectors.toList());

// ОШИБКА 3: создание бесконечного потока
List<Integer> result = numbers.stream()
  .flatMap(n -> Stream.iterate(0, i -> i + 1))  // Бесконечный!
  .limit(10)
  .collect(Collectors.toList());

11. Альтернативы: java.util.stream.Stream.concat()

// Объединение потоков без flatMap
List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(4, 5, 6);

List<Integer> combined = Stream.concat(
  list1.stream(),
  list2.stream()
).collect(Collectors.toList());
// [1, 2, 3, 4, 5, 6]

12. Синтаксис в других языках (для контекста)

// JavaScript
const numbers = [1, 2, 3];
const result = numbers.flatMap(n => [n, n*2]);
// [1, 2, 2, 4, 3, 6]

// Haskell (монадический язык)
-- Монадическое связывание (>>=)
result = [1, 2, 3] >>= (\n -> [n, n*2])

Итоги: идеология flatMap

• Трансформация + Раскрытие — map каждый элемент и развернуть результат
• Монадическое связывание — композиция операций, возвращающих коллекции
• Избежание вложенности — предотвращение List<List<T>>
• Декларативный стиль — что нужно сделать, а не как
• Функциональный паттерн — замена вложенных циклов на читаемый код

flatMap — ключевой инструмент современной Java для обработки потоков данных.