Stream API 基础

// JDK 7：近 20 行代码，可读性差
List<Employee> techEmps = new ArrayList<>();
for (Employee e : employees) {
    if ("技术部".equals(e.getDepartment())) {
        techEmps.add(e);
    }
}
Collections.sort(techEmps, new Comparator<Employee>() {
    @Override
    public int compare(Employee a, Employee b) {
        return Double.compare(b.getSalary(), a.getSalary());
    }
});
List<Employee> top3 = new ArrayList<>();
for (int i = 0; i < Math.min(3, techEmps.size()); i++) {
    top3.add(techEmps.get(i));
}

// JDK 8：一行流式处理，语义清晰
List<Employee> top3 = employees.stream()
    .filter(e -> "技术部".equals(e.getDepartment()))
    .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
    .limit(3)
    .collect(Collectors.toList());

// 1. 从集合创建（最常用）
List<Employee> list = getEmployees();
Stream<Employee> stream1 = list.stream();           // 顺序流
Stream<Employee> parallelStream = list.parallelStream();  // 并行流

// 2. 从数组创建
String[] names = {"大翔", "白歌", "小崔", "孔蓝"};
Stream<String> stream2 = Arrays.stream(names);
Stream<String> subStream = Arrays.stream(names, 1, 3);  // 只取 [白歌, 小崔]

// 3. 直接创建
Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream4 = Stream.of("A", "B", "C");

// 4. 无限流（需要用 limit() 截断）
Stream<Integer> naturalNumbers = Stream.iterate(0, n -> n + 1);  // 0, 1, 2, 3, ...
Stream<Double> randomValues = Stream.generate(Math::random);       // 随机数流

// 5. 从文件读取
try (Stream<String> lines = Files.lines(Paths.get("employees.txt"))) {
    lines.filter(line -> line.contains("技术部"))
         .forEach(System.out::println);
}

// 筛选技术部薪资 > 15000 的员工
List<Employee> techHighSalary = employees.stream()
    .filter(e -> "技术部".equals(e.getDepartment()))
    .filter(e -> e.getSalary() > 15000)
    .collect(Collectors.toList());

// 提取所有员工的姓名列表
List<String> names = employees.stream()
    .map(Employee::getName)
    .collect(Collectors.toList());

// 计算每个员工的年薪
List<Double> annualSalaries = employees.stream()
    .map(emp -> emp.getSalary() * 12)
    .collect(Collectors.toList());

// 场景：每个员工有多个技能标签，获取所有技能的去重列表
class Employee {
    private List<String> skills;  // ["Java", "Spring", ...]
    public List<String> getSkills() { return skills; }
}

// 错误做法：map 得到的是 Stream<List<String>>
Stream<List<String>> skillLists = employees.stream().map(Employee::getSkills);

// 正确做法：flatMap 得到 Stream<String>
List<String> allSkills = employees.stream()
    .flatMap(emp -> emp.getSkills().stream())
    .distinct()
    .collect(Collectors.toList());

// 按薪资降序排列
List<Employee> bySalary = employees.stream()
    .sorted((a, b) -> Double.compare(b.getSalary(), a.getSalary()))
    .collect(Collectors.toList());

// 使用 Comparator 工具方法（推荐）
List<Employee> bySalary2 = employees.stream()
    .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
    .collect(Collectors.toList());

// 多级排序：先按部门，再按薪资
List<Employee> multiSort = employees.stream()
    .sorted(Comparator.comparing(Employee::getDepartment)
                      .thenComparing(Comparator.comparingDouble(Employee::getSalary).reversed()))
    .collect(Collectors.toList());

// 使用 peek 观察管道中每一步的数据变化
List<String> result = employees.stream()
    .peek(e -> System.out.println("原始: " + e))
    .filter(e -> e.getSalary() > 15000)
    .peek(e -> System.out.println("  过滤后: " + e))
    .map(Employee::getName)
    .peek(name -> System.out.println("    映射后: " + name))
    .collect(Collectors.toList());

// 获取薪资最高的前 3 名
List<Employee> top3 = employees.stream()
    .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
    .limit(3)
    .collect(Collectors.toList());

// 分页：第 2 页，每页 10 条
int page = 2;
int pageSize = 10;
List<Employee> page2 = employees.stream()
    .skip((page - 1) * pageSize)
    .limit(pageSize)
    .collect(Collectors.toList());

// 生成前 100 个斐波那契数对
Stream.iterate(new long[]{0, 1}, f -> new long[]{f[1], f[0] + f[1]})
    .limit(100)           // 短路：只处理 100 个
    .map(f -> f[0])
    .forEach(System.out::println);

// findFirst 短路示例
Optional<Employee> firstHighSalary = employees.stream()
    .filter(e -> e.getSalary() > 50000)
    .findFirst();         // 找到第一个就停止，不会处理后续元素

public class LazyEvaluationDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("大翔", "白歌", "小崔", "孔蓝");

        System.out.println("=== 实验1：无终端操作 ===");
        Stream<String> stream = names.stream()
            .filter(name -> {
                System.out.println("  filter 正在处理: " + name);
                return name.length() > 1;
            })
            .map(name -> {
                System.out.println("  map 正在处理: " + name);
                return name.toUpperCase();
            });
        System.out.println("Stream 管道已构建，但没有任何输出！");

        System.out.println("\n=== 实验2：添加终端操作后 ===");
        // 此时才真正执行
        List<String> result = stream.collect(Collectors.toList());
        System.out.println("结果: " + result);
    }
}

import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class EmployeeQueryDemo {
    public static void main(String[] args) {
        // 准备测试数据
        List<Employee> employees = Arrays.asList(
            new Employee("大翔", 50000, "管理层", LocalDate.of(2015, 3, 1), 
                Arrays.asList("管理", "战略", "Java")),
            new Employee("白歌", 35000, "技术部", LocalDate.of(2017, 6, 15),
                Arrays.asList("Java", "Spring", "架构", "分布式")),
            new Employee("小崔", 18000, "技术部", LocalDate.of(2021, 7, 1),
                Arrays.asList("Java", "MyBatis", "SQL")),
            new Employee("孔蓝", 12000, "技术部", LocalDate.of(2023, 9, 1),
                Arrays.asList("Python", "AI", "Django")),
            new Employee("老刘", 9000, "后勤部", LocalDate.of(2018, 1, 10),
                Arrays.asList("采购", "物流")),
            new Employee("阿杰", 25000, "产品部", LocalDate.of(2019, 4, 20),
                Arrays.asList("需求分析", "Axure", "数据分析")),
            new Employee("小美", 15000, "产品部", LocalDate.of(2022, 11, 5),
                Arrays.asList("UI设计", "Figma", "用户体验"))
        );

        System.out.println("=== 1. 技术部薪资 > 15000 的员工，按薪资降序 ===");
        employees.stream()
            .filter(e -> "技术部".equals(e.getDepartment()))
            .filter(e -> e.getSalary() > 15000)
            .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
            .forEach(e -> System.out.printf("  %s, 薪资: %.0f%n", e.getName(), e.getSalary()));

        System.out.println("\n=== 2. 各部门的员工名单（flatMap 展平技能） ===");
        Map<String, List<String>> deptEmployees = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.mapping(Employee::getName, Collectors.toList())
            ));
        deptEmployees.forEach((dept, names) -> 
            System.out.printf("  %s: %s%n", dept, names));

        System.out.println("\n=== 3. 所有技能去重列表 ===");
        List<String> allSkills = employees.stream()
            .flatMap(e -> e.getSkills().stream())
            .distinct()
            .sorted()
            .collect(Collectors.toList());
        System.out.println("  " + allSkills);

        System.out.println("\n=== 4. 薪资分页（第1页，每页3条） ===");
        List<Employee> page1 = employees.stream()
            .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
            .limit(3)
            .collect(Collectors.toList());
        page1.forEach(e -> System.out.printf("  %s: %.0f%n", e.getName(), e.getSalary()));

        System.out.println("\n=== 5. 统计信息 ===");
        long techCount = employees.stream()
            .filter(e -> "技术部".equals(e.getDepartment()))
            .count();
        boolean hasHighSalary = employees.stream()
            .anyMatch(e -> e.getSalary() > 40000);
        boolean allHaveName = employees.stream()
            .allMatch(e -> e.getName() != null && !e.getName().isEmpty());
        System.out.printf("  技术部人数: %d%n", techCount);
        System.out.printf("  存在薪资 > 40000: %b%n", hasHighSalary);
        System.out.printf("  所有员工都有姓名: %b%n", allHaveName);

        System.out.println("\n=== 6. 首个薪资最低的员工 ===");
        employees.stream()
            .min(Comparator.comparingDouble(Employee::getSalary))
            .ifPresent(e -> System.out.printf("  最低薪资: %s, %.0f%n", e.getName(), e.getSalary()));
    }
}

import java.util.stream.Stream;

public class InfiniteStreamDemo {
    public static void main(String[] args) {
        // 生成员工编号：EMP-2024-0001 格式
        System.out.println("=== 生成前 10 个员工编号 ===");
        Stream.iterate(1, n -> n + 1)
            .limit(10)
            .map(n -> String.format("EMP-2024-%04d", n))
            .forEach(System.out::println);

        // 斐波那契数列
        System.out.println("\n=== 前 10 个斐波那契数 ===");
        Stream.iterate(new long[]{0, 1}, f -> new long[]{f[1], f[0] + f[1]})
            .limit(10)
            .map(f -> f[0])
            .forEach(n -> System.out.print(n + " "));
        System.out.println();

        // 生成随机薪资数据（18000 ~ 50000）
        System.out.println("\n=== 生成 5 个随机薪资 ===");
        Stream.generate(() -> Math.random() * 32000 + 18000)
            .limit(5)
            .map(salary -> Math.round(salary * 100) / 100.0)
            .forEach(salary -> System.out.printf("  %.2f%n", salary));

        // 验证短路：在无限流中找第一个满足条件的
        System.out.println("\n=== 在无限流中找第一个 > 45000 的值 ===");
        Stream.generate(() -> Math.random() * 32000 + 18000)
            .peek(v -> System.out.printf("  检查: %.2f%n", v))
            .filter(v -> v > 45000)
            .findFirst()
            .ifPresent(v -> System.out.printf("找到! %.2f%n", v));
    }
}

// ❌ 错误：Stream 只能消费一次
Stream<Employee> stream = employees.stream().filter(e -> e.getSalary() > 15000);
List<Employee> list1 = stream.collect(Collectors.toList());   // 第一次消费 OK
List<Employee> list2 = stream.collect(Collectors.toList());   // IllegalStateException

// ✅ 正确：使用 Supplier 包装，每次需要时重新创建
Supplier<Stream<Employee>> streamSupplier = () -> 
    employees.stream().filter(e -> e.getSalary() > 15000);
List<Employee> list1 = streamSupplier.get().collect(Collectors.toList());
List<Employee> list2 = streamSupplier.get().collect(Collectors.toList());

// ❌ 错误：期望 filter 中的打印语句执行，但忘了加终端操作
employees.stream()
    .filter(e -> {
        System.out.println("处理: " + e.getName());  // 这行永远不会执行！
        return e.getSalary() > 15000;
    });
System.out.println("完成");
// 输出只有 "完成"，没有员工信息

// ✅ 正确：添加终端操作触发执行
employees.stream()
    .filter(e -> {
        System.out.println("处理: " + e.getName());
        return e.getSalary() > 15000;
    })
    .collect(Collectors.toList());  // 必须有终端操作

// ❌ 错误：在 filter 的 Lambda 中修改外部集合——副作用 + 非线程安全
List<Employee> highSalary = new ArrayList<>();
employees.stream()
    .filter(e -> {
        if (e.getSalary() > 15000) {
            highSalary.add(e);  // 副作用！不应在 Stream 操作中修改外部状态
        }
        return true;
    })
    .collect(Collectors.toList());

// ✅ 正确：使用 collect 收集结果
List<Employee> highSalary = employees.stream()
    .filter(e -> e.getSalary() > 15000)
    .collect(Collectors.toList());

// ❌ 错误认知：以为 sorted() 会完整排序所有元素
// 实际上 JDK 的 sorted() 实现确实会完整排序（对于 Collection.stream()），
// 但如果数据量很大，limit(3) 无法帮助 sorted() 减少工作量
employees.stream()
    .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
    .limit(3)  // limit 只是从排序结果中截取，排序仍然处理了所有元素
    .collect(Collectors.toList());

// ✅ 优化：如果只需要 Top N，考虑使用优先队列（PriorityQueue）
// 或者在使用并行流时，sorted 的实现会更高效
// 对于极大数据集，手动实现 Top N 算法比 sorted().limit(N) 更高效