Java Stream 的 collect 与 reduce 操作示例详解

// 将 Stream 转换为 List
List<String> names = Stream.of("Alice", "Bob", "Charlie")
    .collect(Collectors.toList());
// 将 Stream 转换为 Set 去重
Set<Integer> uniqueNumbers = Stream.of(1, 2, 2, 3, 3, 3)
    .collect(Collectors.toSet());
// 使用 toCollection 指定具体集合类型
LinkedList<String> linkedList = Stream.of("a", "b", "c")
    .collect(Collectors.toCollection(LinkedList::new));

class Person {
    private String name;
    private int age;
    private String city;
    // 构造器、getter 略
}
// 按城市分组
Map<String, List<Person>> peopleByCity = personStream
    .collect(Collectors.groupingBy(Person::getCity));
// 按年龄是否大于18分区
Map<Boolean, List<Person>> partitionByAge = personStream
    .collect(Collectors.partitioningBy(p -> p.getAge() > 18));

// 自定义 Collector 实现字符串拼接
Collector<String, StringBuilder, String> stringCollector = Collector.of(
    StringBuilder::new,                  // 创建容器
    StringBuilder::append,               // 累积元素
    (sb1, sb2) -> sb1.append(sb2),       // 合并容器
    StringBuilder::toString              // 最终转换
);
String result = Stream.of("Hello", " ", "World")
    .collect(stringCollector);  // 输出：Hello World

// 无初始值的 reduce（返回 Optional）
Optional<Integer> sum = Stream.of(1, 2, 3, 4)
    .reduce(Integer::sum);  // 结果：10
// 有初始值的 reduce
int product = Stream.of(1, 2, 3, 4)
    .reduce(1, (a, b) -> a * b);  // 结果：24
// 复杂累积：字符串拼接
String concatenated = Stream.of("a", "b", "c")
    .reduce("", String::concat);  // 结果：abc

// 并行流中使用带 combiner 的 reduce
int sum = Stream.of(1, 2, 3, 4)
    .parallel()
    .reduce(0,  // 初始值
        Integer::sum,  // 累积器
        Integer::sum); // 合并器（并行流必须）

// 计算最大值
Optional<Integer> max = Stream.of(5, 3, 9, 1)
    .reduce((a, b) -> a > b ? a : b);  // 结果：9
// 计算平均值（需要自定义累积器）
class Average {
    private int sum;
    private int count;
    public double get() {
        return count > 0 ? (double) sum / count : 0;
    }
}
Average average = Stream.of(1, 2, 3, 4, 5)
    .reduce(new Average(),
        (avg, num) -> {
            avg.sum += num;
            avg.count++;
            return avg;
        },
        (avg1, avg2) -> {
            avg1.sum += avg2.sum;
            avg1.count += avg2.count;
            return avg1;
        });
double result = average.get();  // 结果：3.0

// 使用 collect
double averageAge = employees.stream()
    .collect(Collectors.averagingInt(Employee::getAge));
// 使用 reduce
OptionalDouble averageAge = employees.stream()
    .mapToInt(Employee::getAge)
    .average();

// 使用 collect（推荐）
Map<String, List<Employee>> employeesByDepartment = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));
// 使用 reduce（复杂且低效）
Map<String, List<Employee>> result = employees.stream()
    .reduce(
        new HashMap<>(),
        (map, emp) -> {
            map.computeIfAbsent(emp.getDepartment(), k -> new ArrayList<>())
               .add(emp);
            return map;
        },
        (m1, m2) -> {
            m2.forEach((dept, emps) -> 
                m1.computeIfAbsent(dept, k -> new ArrayList<>())
                  .addAll(emps));
            return m1;
        }
    );

// 使用 collect
String result = words.stream()
    .collect(Collectors.joining(", "));
// 使用 reduce
String result = words.stream()
    .reduce("", (s1, s2) -> s1.isEmpty() ? s2 : s1 + ", " + s2);

// 先分组，再计算每组的平均值
Map<String, Double> avgScoreByClass = students.stream()
    .collect(Collectors.groupingBy(
        Student::getClassName,
        Collectors.averagingDouble(Student::getScore)
    ));