Java Stream 的 flatMap 与 map 的核心区别从原理到实战应用全解析

List<List<Integer>> nestedList = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4)
);
// map操作：返回Stream<List<Integer>>
Stream<List<Integer>> mapResult = nestedList.stream().map(list -> list);
// flatMap操作：返回Stream<Integer>
Stream<Integer> flatMapResult = nestedList.stream().flatMap(list -> list.stream());

// 案例：字符串转大写
List<String> names = Arrays.asList("alice", "bob");
List<String> upperNames = names.stream()
    .map(String::toUpperCase)  // 每个元素独立转换
    .collect(Collectors.toList());  // [ALICE, BOB]
// 数据流向：
// ["alice", "bob"] → map → ["ALICE", "BOB"] → 流结构不变

// 案例：展开嵌套列表
List<String> words = Arrays.asList("a,b", "c,d");
List<String> characters = words.stream()
    .flatMap(s -> Arrays.stream(s.split(",")))  // 每个字符串拆分为流再合并
    .collect(Collectors.toList());  // [a, b, c, d]
// 数据流向：
// ["a,b", "c,d"] → flatMap → ["a","b"]流 + ["c","d"]流 → 合并为["a","b","c","d"]

// 案例：提取用户年龄
List<User> users = ...;
List<Integer> ages = users.stream()
    .map(User::getAge)
    .collect(Collectors.toList());

// 案例：处理每个用户的订单流
class User {
    Stream<Order> getOrders() { ... }
}
List<Order> allOrders = users.stream()
    .flatMap(User::getOrders)  // 展开每个用户的订单流
    .collect(Collectors.toList());

// 反例：对小列表使用flatMap
List<List<Integer>> smallList = Arrays.asList(
    Arrays.asList(1),
    Arrays.asList(2)
);
Stream<Integer> inefficient = smallList.stream().flatMap(list -> list.stream());
// 优化：先map再flatMap（或直接合并）
Stream<Integer> efficient = smallList.stream()
    .map(list -> list.stream())
    .reduce(Stream::concat)
    .orElse(Stream.empty());

// 低效：对象流装箱
Stream<Integer> boxed = list.stream().flatMap(l -> l.stream());
// 高效：IntStream直接操作
IntStream primitive = list.stream().flatMapToInt(l -> l.stream().mapToInt(i -> i));

// 案例：处理三层嵌套结构 List<List<List<Integer>>>
List<List<List<Integer>>> tripleNested = ...;
List<Integer> flatResult = tripleNested.stream()
    .flatMap(doubleList -> doubleList.stream())  // 先展开一层
    .flatMap(singleList -> singleList.stream())  // 再展开一层
    .collect(Collectors.toList());

// 案例：用户转订单并展开
class User {
    String id;
    List<Order> orders;
}
class Order {
    String orderId;
    List<Item> items;
}
class Item {
    String name;
}
// 提取所有用户的所有订单项名称
List<String> itemNames = users.stream()
    .map(user -> user.orders)  // map转换为订单列表
    .flatMap(orders -> orders.stream())  // 展开订单
    .map(order -> order.items)  // map转换为订单项列表
    .flatMap(items -> items.stream())  // 展开订单项
    .map(Item::getName)
    .collect(Collectors.toList());

// 案例：安全获取用户地址
class User {
    Optional<Address> getAddress() { ... }
}
class Address {
    Optional<String> getCity() { ... }
}
// 用map需要多层判断
String city1 = user.stream()
    .map(User::getAddress)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .map(Address::getCity)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .orElse("Unknown");
// 用flatMap简化为空安全链
String city2 = user.stream()
    .flatMap(user -> user.getAddress())  // Optional<Address>转Address流
    .flatMap(Address::getCity)  // Address转Optional<String>再转String流
    .findFirst()
    .orElse("Unknown");

// 反例：用map处理嵌套列表（结果仍是嵌套流）
List<List<Integer>> nested = ...;
Stream<List<Integer>> wrong = nested.stream().map(list -> list);
// 正确：用flatMap展开
Stream<Integer> correct = nested.stream().flatMap(list -> list.stream());

// 错误：可能返回null流
Stream<String> risky = data.stream().flatMap(item -> item.process());
// 安全：先过滤null
Stream<String> safe = data.stream()
    .filter(Objects::nonNull)
    .flatMap(item -> item.process());

// 低效：对单层列表使用flatMap
List<String> words = ...;
Stream<String> inefficient = words.stream().flatMap(s -> Stream.of(s));
// 高效：直接使用map
Stream<String> efficient = words.stream().map(s -> s);