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

// 案例：字符串轉(zhuǎn)大寫
List<String> names = Arrays.asList("alice", "bob");
List<String> upperNames = names.stream()
    .map(String::toUpperCase)  // 每個元素獨(dú)立轉(zhuǎn)換
    .collect(Collectors.toList());  // [ALICE, BOB]
// 數(shù)據(jù)流向：
// ["alice", "bob"] → map → ["ALICE", "BOB"] → 流結(jié)構(gòu)不變

// 案例：展開嵌套列表
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]
// 數(shù)據(jù)流向：
// ["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());
// 優(yōu)化：先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));

// 案例：處理三層嵌套結(jié)構(gòu) 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());

// 案例：用戶轉(zhuǎn)訂單并展開
class User {
    String id;
    List<Order> orders;
}
class Order {
    String orderId;
    List<Item> items;
}
class Item {
    String name;
}
// 提取所有用戶的所有訂單項(xiàng)名稱
List<String> itemNames = users.stream()
    .map(user -> user.orders)  // map轉(zhuǎn)換為訂單列表
    .flatMap(orders -> orders.stream())  // 展開訂單
    .map(order -> order.items)  // map轉(zhuǎn)換為訂單項(xiàng)列表
    .flatMap(items -> items.stream())  // 展開訂單項(xiàng)
    .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>轉(zhuǎn)Address流
    .flatMap(Address::getCity)  // Address轉(zhuǎn)Optional<String>再轉(zhuǎn)String流
    .findFirst()
    .orElse("Unknown");

// 反例：用map處理嵌套列表（結(jié)果仍是嵌套流）
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);