Stream API ⭐⭐

// 传统集合方式：命令式，告诉计算机"怎么做"
// 找出所有大于 10 的数字，乘以 2，收集到新列表
List<Integer> numbers = Arrays.asList(3, 15, 7, 22, 8, 19);
List<Integer> result = new ArrayList<>();       // 手动创建结果容器
for (Integer n : numbers) {                     // 手动遍历
    if (n > 10) {                               // 手动判断条件
        result.add(n * 2);                      // 手动转换并添加
    }
}
 
// Stream 方式：声明式，告诉计算机"做什么"
List<Integer> result = numbers.stream()         // 从集合创建 Stream
    .filter(n -> n > 10)                        // 声明：只要大于 10 的
    .map(n -> n * 2)                            // 声明：每个元素乘以 2
    .collect(Collectors.toList());              // 声明：收集为 List

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
 
// 这段代码执行后，filter 和 map 都【不会】真正运行
// 它们只是被"登记"到了流水线的操作链上
Stream<String> lazyStream = names.stream()
    .filter(name -> {
        System.out.println("filtering: " + name);  // 用于观察是否执行
        return name.length() > 3;
    })
    .map(name -> {
        System.out.println("mapping: " + name);    // 用于观察是否执行
        return name.toUpperCase();
    });
 
// 到这里为止，控制台没有任何输出！
// 因为还没有终端操作，流水线根本没有启动
System.out.println("--- 终端操作即将触发 ---");
 
// 调用 collect() 终端操作，流水线才真正启动
List<String> result = lazyStream.collect(Collectors.toList());
// 现在控制台才会打印 filtering 和 mapping 的日志

List<Integer> hugeList = IntStream.rangeClosed(1, 10_000_000)
    .boxed()                                    // 将 int 装箱为 Integer
    .collect(Collectors.toList());              // 一千万个元素的列表
 
// 找到第一个大于 100 的偶数
Optional<Integer> first = hugeList.stream()
    .filter(n -> n % 2 == 0)                   // 中间操作：筛选偶数
    .filter(n -> n > 100)                      // 中间操作：大于 100
    .findFirst();                              // 终端操作：找到第一个就停
 
// 实际只处理了前 102 个元素（2,4,6,...,100,102）
// 而不是遍历全部一千万个元素！
System.out.println(first.get());               // 输出: 102

// 生成一个"无限"的偶数流
// 如果不是惰性求值，这行代码会直接内存溢出
Stream<Integer> infiniteEvens = Stream.iterate(0, n -> n + 2);
 
// 但配合 limit()，只取前 10 个，完全安全
List<Integer> firstTen = infiniteEvens
    .limit(10)                                 // 只取前 10 个元素
    .collect(Collectors.toList());             // [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

List<String> words = Arrays.asList("hello", "world", "java");
 
Stream<String> stream = words.stream();        // 创建一个 Stream
 
// 第一次消费：正常执行
long count = stream.count();                   // 终端操作，Stream 被消费
System.out.println("count = " + count);        // 输出: count = 3
 
// 第二次消费：抛出异常！
// stream.forEach(System.out::println);        // ❌ IllegalStateException!
// 错误信息: stream has already been operated upon or closed

List<String> words = Arrays.asList("hello", "world", "java", "stream");
 
// ✅ 正确做法：每次需要时从数据源重新创建 Stream
long count = words.stream().count();                          // 第一条流水线
List<String> upper = words.stream()                           // 第二条流水线（全新的）
    .map(String::toUpperCase)
    .collect(Collectors.toList());
 
System.out.println("count = " + count);                       // 3
System.out.println("upper = " + upper);                       // [HELLO, WORLD, JAVA, STREAM]

// 用 Supplier 封装 Stream 的创建过程
Supplier<Stream<String>> streamFactory = () -> words.stream()
    .filter(w -> w.length() > 4);              // 公共的前置过滤逻辑
 
// 每次调用 get() 都会创建一个全新的 Stream
long count = streamFactory.get().count();                     // 消费第一个 Stream
String joined = streamFactory.get()                           // 消费第二个 Stream（全新的）
    .collect(Collectors.joining(", "));
 
System.out.println(count);                                    // 2 (hello, world, stream)
System.out.println(joined);                                   // hello, world, stream

List<String> list = Arrays.asList("a", "bb", "ccc", "dddd");
Stream<String> s = list.stream()
    .filter(x -> {
        System.out.println("filter: " + x);
        return x.length() >= 2;
    })
    .map(x -> {
        System.out.println("map: " + x);
        return x.toUpperCase();
    });
System.out.println("---ready---");
String result = s.findFirst().orElse("");
System.out.println(result);

// 从 List 创建 Stream
List<String> languages = List.of("Java", "Kotlin", "Scala", "Groovy");
// .stream() 返回一个 Stream<String>，元素顺序与 List 一致
Stream<String> langStream = languages.stream();
// 遍历输出每个元素
langStream.forEach(System.out::println); // Java Kotlin Scala Groovy
 
// 从 Set 创建 Stream
Set<Integer> numbers = new HashSet<>(Arrays.asList(3, 1, 4, 1, 5));
// Set 本身无序且去重，所以 Stream 中的元素顺序不保证
Stream<Integer> numStream = numbers.stream();
numStream.forEach(System.out::println); // 输出顺序不确定
 
// 从 Queue 创建 Stream
Queue<String> queue = new LinkedList<>();
queue.offer("first");   // 入队
queue.offer("second");  // 入队
queue.offer("third");   // 入队
// Queue 也是 Collection 的子接口，同样支持 .stream()
Stream<String> queueStream = queue.stream();
queueStream.forEach(System.out::println); // first second third

List<String> list = new ArrayList<>(List.of("A", "B", "C"));
 
// ❌ 错误示范：在 Stream 消费过程中修改底层集合
list.stream().forEach(item -> {
    if ("B".equals(item)) {
        list.remove(item); // 触发 ConcurrentModificationException
    }
});
 
// ✅ 正确做法：先用 Stream 筛选，再收集为新集合
List<String> filtered = list.stream()
        .filter(item -> !"B".equals(item)) // 过滤掉 "B"
        .collect(Collectors.toList());      // 收集到新 List

// 1. 从对象数组创建 Stream<String>
String[] fruits = {"Apple", "Banana", "Cherry", "Date"};
// Arrays.stream() 接收一个数组，返回对应类型的 Stream
Stream<String> fruitStream = Arrays.stream(fruits);
fruitStream.forEach(System.out::println); // Apple Banana Cherry Date
 
// 2. 从基本类型数组创建——返回的是 IntStream，不是 Stream<Integer>
int[] scores = {88, 92, 76, 95, 61};
// 对 int[] 调用 Arrays.stream() 会返回 IntStream（基本类型特化流）
IntStream scoreStream = Arrays.stream(scores);
// IntStream 提供了 sum()、average() 等数值专用终端操作
int total = scoreStream.sum(); // 直接求和：88+92+76+95+61 = 412
System.out.println("总分: " + total); // 总分: 412
 
// 3. 截取数组的一部分来创建 Stream（左闭右开区间）
// 第二个参数是起始索引（含），第三个参数是结束索引（不含）
Stream<String> subStream = Arrays.stream(fruits, 1, 3);
subStream.forEach(System.out::println); // Banana Cherry

// 对比：装箱流 vs 基本类型流
int[] data = new int[1_000_000]; // 一百万个 int
Arrays.fill(data, 1);           // 全部填充为 1
 
// ✅ 推荐：IntStream，无装箱开销
long sum1 = Arrays.stream(data).sum(); // 直接在 int 层面求和
 
// ❌ 不推荐：Stream<Integer>，每个 int 都要装箱为 Integer 对象
long sum2 = Arrays.stream(data)
        .boxed()                       // int → Integer，产生一百万个对象
        .reduce(0, Integer::sum);      // 在 Integer 层面归约

// 传入多个元素，快速创建 Stream
Stream<String> stream1 = Stream.of("Hello", "Stream", "API");
stream1.forEach(System.out::println); // Hello Stream API
 
// 也可以传入单个元素
Stream<Integer> stream2 = Stream.of(42);
stream2.forEach(System.out::println); // 42
 
// 传入一个数组——注意这里的行为差异！
String[] arr = {"X", "Y", "Z"};
// Stream.of(arr) 会展开数组，等价于 Stream.of("X", "Y", "Z")
Stream<String> stream3 = Stream.of(arr);
stream3.forEach(System.out::println); // X Y Z
 
// ⚠️ 但如果传入 int[]，行为完全不同
int[] intArr = {1, 2, 3};
// Stream.of(intArr) 把整个 int[] 当作一个元素！返回 Stream<int[]>
Stream<int[]> stream4 = Stream.of(intArr);
System.out.println(stream4.count()); // 1（只有一个元素，就是那个数组本身）
 
// 正确做法：用 Arrays.stream(intArr) 或 IntStream.of(1, 2, 3)
IntStream intStream = IntStream.of(1, 2, 3);
intStream.forEach(System.out::println); // 1 2 3

// 创建空流，常用于方法返回值的边界处理
Stream<String> emptyStream = Stream.empty();
System.out.println(emptyStream.count()); // 0
 
// 实际应用：安全地处理可能为 null 的集合
public static <T> Stream<T> safeStream(Collection<T> collection) {
    // 如果集合为 null，返回空流而不是抛出 NullPointerException
    return collection == null ? Stream.empty() : collection.stream();
}

// 1. 生成常量流——每个元素都是 "Echo"
Stream<String> echoStream = Stream.generate(() -> "Echo");
// 必须用 limit() 截断，否则无限输出
echoStream.limit(3).forEach(System.out::println);
// Echo
// Echo
// Echo
 
// 2. 生成随机数流
Random random = new Random();
// random::nextInt 是方法引用，等价于 () -> random.nextInt()
Stream<Integer> randomStream = Stream.generate(random::nextInt);
randomStream
        .limit(5)                          // 只取 5 个
        .forEach(System.out::println);     // 5 个随机整数
 
// 3. 生成 UUID 流——每次调用都产生一个全新的 UUID
Stream.generate(UUID::randomUUID)
        .limit(3)                          // 取 3 个
        .map(UUID::toString)               // 转为字符串
        .forEach(System.out::println);     // 3 个不同的 UUID 字符串
 
// 4. 利用外部状态生成递增序列（⚠️ 不推荐，有副作用）
AtomicInteger counter = new AtomicInteger(0);
Stream.generate(counter::getAndIncrement)
        .limit(5)
        .forEach(System.out::println); // 0 1 2 3 4
// 虽然能工作，但 Supplier 依赖了外部可变状态，违反函数式编程原则
// 这种场景应该用 Stream.iterate() 或 IntStream.range()

// 基本形式：iterate(seed, UnaryOperator)
// seed 是初始值，UnaryOperator 定义了 "如何从当前元素得到下一个元素"
 
// 1. 生成等差数列：0, 2, 4, 6, 8, ...
Stream.iterate(0, n -> n + 2)      // 从 0 开始，每次 +2
        .limit(5)                   // 取前 5 个
        .forEach(System.out::println); // 0 2 4 6 8
 
// 2. 生成等比数列：1, 2, 4, 8, 16, ...
Stream.iterate(1, n -> n * 2)      // 从 1 开始，每次 ×2
        .limit(6)                   // 取前 6 个
        .forEach(System.out::println); // 1 2 4 8 16 32
 
// 3. 生成斐波那契数列（利用数组保存两个状态）
Stream.iterate(
        new long[]{0, 1},           // 初始状态：[F(0), F(1)]
        pair -> new long[]{pair[1], pair[0] + pair[1]} // [F(n), F(n+1)] → [F(n+1), F(n+2)]
)
        .limit(10)                  // 取前 10 组
        .map(pair -> pair[0])       // 只取每组的第一个值
        .forEach(System.out::println);
// 0 1 1 2 3 5 8 13 21 34

// Java 9+ 三参数 iterate：iterate(seed, hasNext, next)
// 类似传统 for 循环：for (int i = seed; hasNext(i); i = next(i))
 
// 等价于 for (int i = 0; i < 10; i += 2)
Stream.iterate(0, n -> n < 10, n -> n + 2)
        .forEach(System.out::println); // 0 2 4 6 8
 
// 遍历日期：从今天开始，到月底为止，每次 +1 天
LocalDate today = LocalDate.now();
LocalDate endOfMonth = today.withDayOfMonth(today.lengthOfMonth());
 
Stream.iterate(
        today,                              // 起始日期
        date -> !date.isAfter(endOfMonth),  // 终止条件：不超过月底
        date -> date.plusDays(1)             // 每次加一天
).forEach(System.out::println);
// 输出从今天到月底的每一天

// 1. IntStream.range() / rangeClosed()——生成整数区间
IntStream.range(1, 5)        // [1, 5)，不含 5
        .forEach(System.out::print); // 1234
System.out.println();
IntStream.rangeClosed(1, 5)  // [1, 5]，含 5
        .forEach(System.out::print); // 12345
 
// 2. Files.lines()——按行读取文件，返回 Stream<String>
// 注意：需要在 try-with-resources 中使用，确保文件句柄被关闭
try (Stream<String> lines = Files.lines(Path.of("data.txt"), StandardCharsets.UTF_8)) {
    lines.filter(line -> !line.isBlank())   // 过滤空行
         .map(String::trim)                 // 去除首尾空白
         .forEach(System.out::println);     // 逐行输出
} // 自动关闭底层文件资源
 
// 3. Pattern.splitAsStream()——用正则表达式分割字符串为 Stream
Pattern pattern = Pattern.compile(",\\s*"); // 匹配逗号及其后的空白
Stream<String> parts = pattern.splitAsStream("Java, Kotlin, Scala, Groovy");
parts.forEach(System.out::println); // Java Kotlin Scala Groovy
 
// 4. String.chars()——Java 9+，将字符串拆为 IntStream（每个字符的 Unicode 码点）
"Hello".chars()                            // 返回 IntStream
       .mapToObj(c -> (char) c)            // int → char
       .forEach(System.out::print);        // Hello
 
// 5. Stream.concat()——拼接两个 Stream 为一个
Stream<String> s1 = Stream.of("A", "B");
Stream<String> s2 = Stream.of("C", "D");
Stream<String> merged = Stream.concat(s1, s2); // A B C D
merged.forEach(System.out::print); // ABCD

int[] nums = {1, 2, 3};
long count = Stream.of(nums).count();
System.out.println(count);

Stream<T> filter(Predicate<? super T> predicate)

// 从一组整数中筛选出所有偶数
List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 
List<Integer> evens = numbers.stream()   // 创建流
        .filter(n -> n % 2 == 0)         // 只保留能被2整除的元素
        .collect(Collectors.toList());   // 终端操作：收集为List
 
System.out.println(evens); // 输出: [2, 4, 6, 8, 10]

// 定义员工类
record Employee(String name, int age, double salary, String department) {}
 
List<Employee> employees = List.of(
        new Employee("Alice", 30, 85000, "Engineering"),
        new Employee("Bob", 25, 62000, "Marketing"),
        new Employee("Charlie", 35, 95000, "Engineering"),
        new Employee("Diana", 28, 71000, "Engineering"),
        new Employee("Eve", 40, 110000, "Management")
);
 
// 构建可复用的断言条件
Predicate<Employee> isEngineer = e -> "Engineering".equals(e.department());  // 是否工程部
Predicate<Employee> isSenior = e -> e.age() >= 30;                          // 是否年龄>=30
Predicate<Employee> highEarner = e -> e.salary() > 80000;                   // 是否高薪
 
// 组合条件：工程部 且 (资深 或 高薪)
List<Employee> result = employees.stream()
        .filter(isEngineer.and(isSenior.or(highEarner)))  // Predicate组合
        .collect(Collectors.toList());
 
// 结果: Alice(30岁,85k,Engineering), Charlie(35岁,95k,Engineering)
result.forEach(e -> System.out.println(e.name()));

// 写法一：链式 filter（推荐，可读性强）
stream.filter(e -> e.age() > 25)
      .filter(e -> e.salary() > 70000)
      .filter(e -> "Engineering".equals(e.department()));
 
// 写法二：单个 filter 内合并（功能等价）
stream.filter(e -> e.age() > 25 && e.salary() > 70000 && "Engineering".equals(e.department()));

List<String> rawData = Arrays.asList("hello", null, "world", null, "java");
 
List<String> cleaned = rawData.stream()
        .filter(Objects::nonNull)        // 方法引用，等价于 s -> s != null
        .filter(s -> !s.isEmpty())       // 进一步过滤空字符串
        .collect(Collectors.toList());
 
System.out.println(cleaned); // 输出: [hello, world, java]

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

// 从员工列表中提取所有姓名
List<String> names = employees.stream()
        .map(Employee::name)             // 方法引用，等价于 e -> e.name()
        .collect(Collectors.toList());
 
System.out.println(names); // 输出: [Alice, Bob, Charlie, Diana, Eve]

// String -> Integer: 将字符串转换为其长度
List<String> words = List.of("Stream", "API", "is", "powerful");
 
List<Integer> lengths = words.stream()
        .map(String::length)             // String -> Integer
        .collect(Collectors.toList());
 
System.out.println(lengths); // 输出: [6, 3, 2, 8]

// 实体类
record UserEntity(Long id, String username, String email, String passwordHash) {}
 
// DTO类（不暴露密码）
record UserDTO(Long id, String username, String email) {}
 
List<UserEntity> entities = queryFromDatabase(); // 假设从数据库查询
 
// 实体 -> DTO 转换
List<UserDTO> dtos = entities.stream()
        .map(e -> new UserDTO(              // 每个实体映射为一个DTO
                e.id(),                     // 保留id
                e.username(),               // 保留用户名
                e.email()                   // 保留邮箱，丢弃密码
        ))
        .collect(Collectors.toList());

// 经典组合：先过滤，再转换
// 需求：找出工程部所有员工的姓名，转为大写
List<String> engineerNames = employees.stream()
        .filter(e -> "Engineering".equals(e.department()))  // 第一步：筛选工程部
        .map(Employee::name)                                 // 第二步：提取姓名
        .map(String::toUpperCase)                            // 第三步：转大写
        .collect(Collectors.toList());
 
System.out.println(engineerNames); // 输出: [ALICE, CHARLIE, DIANA]

List<String> sentences = List.of("Hello World", "Stream API");
 
// 错误示范：map 产生了 Stream<String[]>，而不是 Stream<String>
List<String[]> wrong = sentences.stream()
        .map(s -> s.split(" "))          // 每个String变成String[]
        .collect(Collectors.toList());
// wrong 的类型是 List<String[]>，不是我们想要的 List<String>

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

map 的结果（嵌套结构）:
┌─────────────────────────────────────────┐
│ Stream< Stream<String> >                │
│  ┌──────────────┐  ┌──────────────┐     │
│  │ Stream:       │  │ Stream:       │    │
│  │ "Hello"       │  │ "Stream"      │    │
│  │ "World"       │  │ "API"         │    │
│  └──────────────┘  └──────────────┘     │
└─────────────────────────────────────────┘
 
flatMap 的结果（扁平结构）:
┌─────────────────────────────────────────┐
│ Stream<String>                          │
│  "Hello", "World", "Stream", "API"      │
└─────────────────────────────────────────┘

List<String> sentences = List.of("Hello World", "Stream API");
 
// 使用 flatMap：每个句子拆成单词流，然后扁平化合并
List<String> words = sentences.stream()
        .flatMap(sentence -> Arrays.stream(sentence.split(" ")))  // String -> Stream<String>
        .collect(Collectors.toList());
 
System.out.println(words); // 输出: [Hello, World, Stream, API]

// 第一步：sentences.stream() 产生 Stream<String>
//   元素: "Hello World", "Stream API"
 
// 第二步：flatMap 对每个元素执行 mapper
//   "Hello World" -> Arrays.stream(["Hello", "World"]) -> Stream: "Hello", "World"
//   "Stream API"  -> Arrays.stream(["Stream", "API"])   -> Stream: "Stream", "API"
 
// 第三步：flatMap 将所有子 Stream 合并为一个
//   最终 Stream: "Hello", "World", "Stream", "API"

// 订单类，每个订单包含多个商品
record Order(String orderId, List<String> items) {}
 
List<Order> orders = List.of(
        new Order("ORD-001", List.of("iPhone", "AirPods")),       // 订单1有2个商品
        new Order("ORD-002", List.of("MacBook", "Mouse", "Pad")), // 订单2有3个商品
        new Order("ORD-003", List.of("iPad"))                     // 订单3有1个商品
);
 
// 需求：获取所有订单中的所有商品（扁平化）
List<String> allItems = orders.stream()
        .flatMap(order -> order.items().stream())  // List<String> -> Stream<String>
        .collect(Collectors.toList());
 
System.out.println(allItems);
// 输出: [iPhone, AirPods, MacBook, Mouse, Pad, iPad]

// 公司 -> 部门 -> 员工 三层嵌套结构
record Company(String name, List<Department> departments) {}
record Department(String name, List<String> employees) {}
 
List<Company> companies = List.of(
        new Company("TechCorp", List.of(
                new Department("Engineering", List.of("Alice", "Bob")),
                new Department("Design", List.of("Charlie"))
        )),
        new Company("DataInc", List.of(
                new Department("Analytics", List.of("Diana", "Eve"))
        ))
);
 
// 需求：获取所有公司所有部门的所有员工姓名
List<String> allEmployees = companies.stream()
        .flatMap(company -> company.departments().stream())   // 第一层展平：公司 -> 部门
        .flatMap(dept -> dept.employees().stream())           // 第二层展平：部门 -> 员工
        .collect(Collectors.toList());
 
System.out.println(allEmployees);
// 输出: [Alice, Bob, Charlie, Diana, Eve]

// 模拟一个可能返回空值的查找方法
Optional<String> findNickname(String name) {
    Map<String, String> nicknames = Map.of("Alice", "Ali", "Charlie", "Chuck");
    return Optional.ofNullable(nicknames.get(name));  // 找不到返回 Optional.empty()
}
 
List<String> names = List.of("Alice", "Bob", "Charlie", "Diana");
 
// 获取所有有昵称的人的昵称
List<String> nicknames = names.stream()
        .map(this::findNickname)              // Stream<Optional<String>>
        .flatMap(Optional::stream)            // 展平：有值保留，empty丢弃
        .collect(Collectors.toList());
 
System.out.println(nicknames); // 输出: [Ali, Chuck]
// Bob 和 Diana 没有昵称，Optional.empty().stream() 产生空流，被自然过滤掉

List<List<Integer>> nested = List.of(
    List.of(1, 2, 3),
    List.of(4, 5),
    List.of(6)
);
 
long result = nested.stream()
    .flatMap(Collection::stream)
    .filter(n -> n % 2 != 0)
    .map(n -> n * n)
    .count();
 
System.out.println(result);

// 形式一：自然排序（Natural Order）
// 要求元素实现 Comparable 接口，否则运行时抛 ClassCastException
Stream<T> sorted();
 
// 形式二：自定义排序（Custom Comparator）
// 传入一个 Comparator，完全由你决定排序规则
Stream<T> sorted(Comparator<? super T> comparator);

// 对整数列表进行自然排序（升序）
List<Integer> numbers = List.of(5, 3, 8, 1, 9, 2, 7);
 
List<Integer> sorted = numbers.stream()
        .sorted()                    // 默认调用 Integer 的 compareTo，升序排列
        .collect(Collectors.toList()); // 收集为新列表
 
System.out.println(sorted); // [1, 2, 3, 5, 7, 8, 9]

List<String> words = List.of("banana", "apple", "cherry", "date");
 
List<String> sortedWords = words.stream()
        .sorted()                    // 字典序：a < b < c < d
        .collect(Collectors.toList());
 
System.out.println(sortedWords); // [apple, banana, cherry, date]

// 假设有一个 Employee 类
record Employee(String name, String department, int salary) {}
 
List<Employee> employees = List.of(
        new Employee("Alice",   "Engineering", 95000),
        new Employee("Bob",     "Marketing",   72000),
        new Employee("Charlie", "Engineering", 88000),
        new Employee("Diana",   "Marketing",   72000),
        new Employee("Eve",     "Engineering", 105000)
);
 
// ① 按薪资升序
List<Employee> bySalaryAsc = employees.stream()
        .sorted(Comparator.comparingInt(Employee::salary)) // 提取 int 字段作为排序键
        .collect(Collectors.toList());
// Bob(72000), Diana(72000), Charlie(88000), Alice(95000), Eve(105000)
 
// ② 按薪资降序 —— 在 comparingInt 后面链式调用 reversed()
List<Employee> bySalaryDesc = employees.stream()
        .sorted(Comparator.comparingInt(Employee::salary).reversed()) // reversed() 反转排序方向
        .collect(Collectors.toList());
// Eve(105000), Alice(95000), Charlie(88000), Bob(72000), Diana(72000)
 
// ③ 多字段排序：先按部门升序，部门相同再按薪资降序
List<Employee> multiSort = employees.stream()
        .sorted(
                Comparator.comparing(Employee::department)          // 第一排序键：部门名（字典序）
                        .thenComparing(                             // 第二排序键
                                Comparator.comparingInt(Employee::salary).reversed() // 薪资降序
                        )
        )
        .collect(Collectors.toList());
// Engineering: Eve(105000), Alice(95000), Charlie(88000)
// Marketing:   Bob(72000), Diana(72000)

List<String> names = Arrays.asList("Charlie", null, "Alice", null, "Bob");
 
List<String> safeSort = names.stream()
        .sorted(
                Comparator.nullsLast(          // null 放到最后
                        Comparator.naturalOrder() // 非 null 元素按自然序排
                )
        )
        .collect(Collectors.toList());
 
System.out.println(safeSort); // [Alice, Bob, Charlie, null, null]

List<Integer> numbers = List.of(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
 
List<Integer> unique = numbers.stream()
        .distinct()                    // 去除重复元素，保留首次出现的顺序
        .collect(Collectors.toList());
 
System.out.println(unique); // [3, 1, 4, 5, 9, 2, 6]

// 错误示范：没有重写 equals/hashCode
class Product {
    String name;  // 产品名称
    double price; // 产品价格
 
    Product(String name, double price) {
        this.name = name;
        this.price = price;
    }
}
 
List<Product> products = List.of(
        new Product("Keyboard", 79.99),
        new Product("Keyboard", 79.99),  // 内容完全相同
        new Product("Mouse", 49.99)
);
 
long count = products.stream().distinct().count();
System.out.println(count); // 3 ← 没去掉！因为默认 equals 比较的是引用地址

// 正确示范：使用 record（自动生成 equals/hashCode）
record Product(String name, double price) {}
 
List<Product> products = List.of(
        new Product("Keyboard", 79.99),
        new Product("Keyboard", 79.99),  // record 会按字段值比较
        new Product("Mouse", 49.99)
);
 
long count = products.stream().distinct().count();
System.out.println(count); // 2 ✓

// 通用的"按字段去重"工具方法
public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet(); // 线程安全的 Set
    return t -> seen.add(keyExtractor.apply(t));      // add 返回 true 表示是新元素
}
 
// 使用：按产品名称去重（保留第一个出现的）
List<Product> uniqueByName = products.stream()
        .filter(distinctByKey(Product::name))  // 只看 name 字段是否重复
        .collect(Collectors.toList());

// distinct 的内部工作原理（概念性伪代码）
// 实际实现在 java.util.stream.DistinctOps 中
Set<Object> seen = new LinkedHashSet<>(); // 记录已见过的元素
for (T element : upstreamElements) {
    if (seen.add(element)) {   // add 成功 → 新元素
        downstream.accept(element); // 放行给下游
    }
    // add 失败 → 重复元素，静默丢弃
}

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 
// limit：只取前 5 个
List<Integer> firstFive = numbers.stream()
        .limit(5)                      // 截断流，最多只让 5 个元素通过
        .collect(Collectors.toList());
System.out.println(firstFive); // [1, 2, 3, 4, 5]
 
// skip：跳过前 5 个
List<Integer> afterFive = numbers.stream()
        .skip(5)                       // 丢弃前 5 个元素，从第 6 个开始放行
        .collect(Collectors.toList());
System.out.println(afterFive); // [6, 7, 8, 9, 10]

// 模拟分页：每页 3 条，取第 2 页（页码从 0 开始）
int pageSize = 3;  // 每页大小
int pageNum = 1;   // 第 2 页（0-indexed）
 
List<Integer> page = numbers.stream()
        .skip((long) pageNum * pageSize) // 跳过前面所有页的元素：1 * 3 = 3
        .limit(pageSize)                 // 只取当前页的元素数量：3
        .collect(Collectors.toList());
 
System.out.println(page); // [4, 5, 6]  ← 第 2 页的内容

// skip + limit 组合：跳过前 3 个，再取 4 个
List<Integer> sliced = numbers.stream()
        .skip(3)                       // 丢弃 [1, 2, 3]
        .limit(4)                      // 从剩余元素中取前 4 个：[4, 5, 6, 7]
        .collect(Collectors.toList());
 
System.out.println(sliced); // [4, 5, 6, 7]

// 用 limit 驯服无限流
List<Integer> firstTenEven = Stream.iterate(0, n -> n + 2) // 无限流：0, 2, 4, 6, 8, ...
        .limit(10)                    // 只取前 10 个，流在此处被截断
        .collect(Collectors.toList());
 
System.out.println(firstTenEven); // [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

// 并行流中 skip 的性能优化
List<Integer> result = hugeList.parallelStream()
        .unordered()                   // 放弃顺序保证，允许并行引擎自由分配
        .skip(1000)                    // 此时 skip 不再需要严格维护顺序
        .limit(100)                    // 取 100 个元素
        .collect(Collectors.toList());

List<Integer> small = List.of(1, 2, 3);
 
// limit 超过实际元素数 → 不报错，返回全部元素
System.out.println(small.stream().limit(100).count()); // 3
 
// skip 超过实际元素数 → 不报错，返回空流
System.out.println(small.stream().skip(100).count());  // 0
 
// limit(0) → 空流
System.out.println(small.stream().limit(0).count());   // 0
 
// skip(0) → 等于没操作
System.out.println(small.stream().skip(0).count());    // 3

Stream<T> peek(Consumer<? super T> action);

List<String> result = Stream.of("one", "two", "three", "four")
        .filter(s -> s.length() > 3)                          // 过滤：长度 > 3
        .peek(s -> System.out.println("经过 filter: " + s))   // 探针 1：看看谁通过了 filter
        .map(String::toUpperCase)                              // 转换：转大写
        .peek(s -> System.out.println("经过 map: " + s))      // 探针 2：看看 map 的输出
        .sorted()                                              // 排序
        .peek(s -> System.out.println("经过 sorted: " + s))   // 探针 3：看看排序后的顺序
        .collect(Collectors.toList());                         // 终端操作：收集
 
// 输出：
// 经过 filter: three
// 经过 map: THREE
// 经过 filter: four
// 经过 map: FOUR
// 经过 sorted: FOUR
// 经过 sorted: THREE

// ❌ 反模式：用 peek 修改外部状态
List<String> debugLog = new ArrayList<>();
 
List<String> result = names.stream()
        .filter(n -> n.length() > 3)
        .peek(n -> debugLog.add(n))    // 危险！在 peek 中修改外部集合
        .map(String::toUpperCase)
        .collect(Collectors.toList());
 
// 问题 1：如果换成并行流，debugLog 不是线程安全的 → 数据竞争
// 问题 2：Stream 的惰性求值意味着 peek 的执行时机不确定
// 问题 3：某些 JVM 优化可能跳过 peek（尤其在没有终端操作时）

// ✅ 正确做法：用 forEach 或在 collect 中处理副作用
List<String> result = names.stream()
        .filter(n -> n.length() > 3)
        .map(String::toUpperCase)
        .collect(Collectors.toList());
 
result.forEach(n -> debugLog.add(n)); // 在终端操作之后，明确地处理副作用

// ✅ 场景 1：开发阶段调试复杂管道
.peek(e -> log.debug("阶段 A 输出: {}", e))
 
// ✅ 场景 2：配合断点调试（在 peek 的 lambda 上打断点）
.peek(e -> {
    // 在这一行打断点，可以逐个检查流中的元素
    String breakpointHere = e.toString();
})
 
// ✅ 场景 3：日志记录（仅限非关键路径，接受可能被跳过的风险）
.peek(e -> logger.trace("Processing: {}", e))

List<Integer> result = Stream.of(5, 3, 8, 1, 9, 2, 7, 4, 6)
        .sorted()
        .skip(2)
        .limit(4)
        .sorted(Comparator.reverseOrder())
        .collect(Collectors.toList());
System.out.println(result);

// forEach 的方法签名
// void forEach(Consumer<? super T> action)
 
import java.util.List;
 
public class ForEachDemo {
    public static void main(String[] args) {
        // 准备一个简单的字符串列表
        List<String> languages = List.of("Java", "Kotlin", "Scala", "Groovy");
 
        // 最基本的用法：打印每个元素
        languages.stream()
                 .forEach(lang -> System.out.println(lang)); // 对每个元素执行打印
 
        // 方法引用写法，更简洁
        languages.stream()
                 .forEach(System.out::println); // 等价于上面的 lambda
 
        // 搭配中间操作使用
        languages.stream()
                 .filter(lang -> lang.startsWith("S"))  // 过滤出以 "S" 开头的语言
                 .map(String::toUpperCase)               // 转为大写
                 .forEach(System.out::println);          // 输出: SCALA
    }
}

import java.util.List;
 
public class ForEachOrderDemo {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6, 7, 8);
 
        System.out.println("=== parallelStream + forEach (顺序不保证) ===");
        nums.parallelStream()
            .forEach(n -> System.out.print(n + " ")); // 输出顺序可能是: 6 5 8 3 4 7 2 1
        System.out.println();
 
        System.out.println("=== parallelStream + forEachOrdered (顺序保证) ===");
        nums.parallelStream()
            .forEachOrdered(n -> System.out.print(n + " ")); // 输出: 1 2 3 4 5 6 7 8
        System.out.println();
    }
}

import java.util.ArrayList;
import java.util.List;
 
public class ForEachAntiPattern {
    public static void main(String[] args) {
        List<String> source = List.of("alpha", "beta", "gamma");
 
        // ❌ 反模式：用 forEach 往外部集合添加元素
        List<String> result = new ArrayList<>();
        source.stream()
              .filter(s -> s.length() > 4)
              .forEach(s -> result.add(s)); // 顺序流下碰巧能工作，但并行流下有并发风险
 
        // ✅ 正确做法：使用 collect
        List<String> safeResult = source.stream()
              .filter(s -> s.length() > 4)
              .collect(java.util.stream.Collectors.toList()); // 线程安全，语义清晰
    }
}

import java.util.List;
 
public class IterableVsStreamForEach {
    public static void main(String[] args) {
        List<String> items = List.of("A", "B", "C");
 
        // 集合自身的 forEach（来自 Iterable 接口）
        items.forEach(System.out::println);       // 简洁，不创建 Stream 对象
 
        // Stream 的 forEach（需要先创建流）
        items.stream().forEach(System.out::println); // 功能相同，但多了一层 Stream 开销
    }
}

// collect 的方法签名
// <R, A> R collect(Collector<? super T, A, R> collector)
//
// T — 流中元素的类型
// A — 中间累积容器的类型 (Accumulator)
// R — 最终返回结果的类型

// Collector 接口的核心抽象（伪代码展示思路）
public interface Collector<T, A, R> {
    Supplier<A> supplier();          // 1. 创建一个空的可变容器
    BiConsumer<A, T> accumulator();  // 2. 将元素逐个放入容器
    BinaryOperator<A> combiner();   // 3. 合并两个容器（并行流时使用）
    Function<A, R> finisher();      // 4. 将容器转换为最终结果
}

以 toList() 为例的执行过程：
 
Stream: ["Java", "Kotlin", "Scala"]
 
Step 1 - supplier():     创建 new ArrayList<>()          → []
Step 2 - accumulator():  list.add("Java")                → ["Java"]
                          list.add("Kotlin")              → ["Java", "Kotlin"]
                          list.add("Scala")               → ["Java", "Kotlin", "Scala"]
Step 3 - combiner():     (并行时) 合并多个子 list
Step 4 - finisher():     返回 ArrayList 本身 (identity)   → ["Java", "Kotlin", "Scala"]

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class ToListDemo {
    public static void main(String[] args) {
        // 基本用法：将流收集为 ArrayList
        List<String> fruits = Stream.of("Apple", "Banana", "Cherry", "Apple")
                .collect(Collectors.toList()); // 返回可变的 ArrayList
        System.out.println(fruits); // [Apple, Banana, Cherry, Apple] — 保留重复元素，保持顺序
 
        // 搭配中间操作
        List<String> filtered = fruits.stream()
                .filter(f -> f.length() > 5)   // 过滤长度大于5的
                .map(String::toUpperCase)       // 转大写
                .collect(Collectors.toList());  // 收集结果
        System.out.println(filtered); // [BANANA, CHERRY]
 
        // Java 16+ 提供了更简洁的 toList()，返回不可变列表
        List<String> immutable = fruits.stream()
                .filter(f -> f.startsWith("A"))
                .toList(); // 注意：返回的是 unmodifiable List
        System.out.println(immutable); // [Apple, Apple]
        // immutable.add("Avocado"); // ❌ 会抛出 UnsupportedOperationException
    }
}

import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class ToSetDemo {
    public static void main(String[] args) {
        // toSet 自动去重，底层通常是 HashSet
        Set<String> uniqueFruits = Stream.of("Apple", "Banana", "Apple", "Cherry", "Banana")
                .collect(Collectors.toSet()); // 去重收集
        System.out.println(uniqueFruits); // [Apple, Banana, Cherry] — 顺序不保证
 
        // 如果需要保持插入顺序，可以用 toCollection 指定 LinkedHashSet
        Set<String> orderedSet = Stream.of("Apple", "Banana", "Apple", "Cherry")
                .collect(Collectors.toCollection(java.util.LinkedHashSet::new));
        System.out.println(orderedSet); // [Apple, Banana, Cherry] — 保持首次出现的顺序
    }
}

import java.util.List;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.stream.Collectors;
 
public class ToMapDemo {
 
    // 模拟一个简单的实体类
    record Employee(int id, String name, String dept, double salary) {}
 
    public static void main(String[] args) {
        List<Employee> employees = List.of(
            new Employee(1, "Alice",   "Engineering", 95000),
            new Employee(2, "Bob",     "Marketing",   72000),
            new Employee(3, "Charlie", "Engineering", 88000),
            new Employee(4, "Diana",   "Marketing",   78000)
        );
 
        // ========== 基本用法：id -> name ==========
        Map<Integer, String> idToName = employees.stream()
                .collect(Collectors.toMap(
                        Employee::id,     // keyMapper: 用 id 作为 key
                        Employee::name    // valueMapper: 用 name 作为 value
                ));
        System.out.println(idToName);
        // {1=Alice, 2=Bob, 3=Charlie, 4=Diana}
 
        // ========== key 冲突处理 ==========
        // 如果多个元素映射到同一个 key，必须提供 mergeFunction，否则抛异常
        Map<String, Double> deptToMaxSalary = employees.stream()
                .collect(Collectors.toMap(
                        Employee::dept,     // keyMapper: 部门名作为 key
                        Employee::salary,   // valueMapper: 薪资作为 value
                        Math::max           // mergeFunction: key 冲突时取较大值
                ));
        System.out.println(deptToMaxSalary);
        // {Engineering=95000.0, Marketing=78000.0}
 
        // ========== 指定 Map 实现类 ==========
        // 第四个参数可以指定具体的 Map 工厂
        Map<Integer, String> orderedMap = employees.stream()
                .collect(Collectors.toMap(
                        Employee::id,              // keyMapper
                        Employee::name,            // valueMapper
                        (v1, v2) -> v1,            // mergeFunction（此处不会冲突，占位）
                        LinkedHashMap::new          // mapFactory: 使用 LinkedHashMap 保持插入顺序
                ));
        System.out.println(orderedMap);
        // {1=Alice, 2=Bob, 3=Charlie, 4=Diana} — 保持顺序
    }
}