public static <T> Collector<T, ?, List<T>> toList() { return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add, (left, right) -> { left.addAll(right); return left; }, CH_ID); }
public static <T> Collector<T, ?, Integer>
summingInt(ToIntFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new int[1],
(a, t) -> { a[0] += mapper.applyAsInt(t); },
(a, b) -> { a[0] += b[0]; return a; },
a -> a[0], CH_NOID);
} java的泛型和函数式接口（lamda表达式）配合，是不是很强大？
是的，Java泛型和函数式接口（lambda表达式）的结合确实非常强大！你提供的两个例子完美展示了这种组合的优势：
这种组合的强大之处体现在：
1. 类型安全与灵活性
JAVA
// 泛型保证类型安全，函数式接口提供灵活性
List<String> names = stream.collect(Collectors.toList());
int sum = stream.collect(Collectors.summingInt(String::length));
2. 代码简洁性
JAVA
// 传统方式 vs 函数式方式
// 传统
List<Integer> list = new ArrayList<>();
for (String s : strings) {
list.add(s.length());
}
// 函数式+泛型
List<Integer> lengths = strings.stream()
.map(String::length)
.collect(Collectors.toList());
3. 组合能力强
JAVA
// 轻松组合多个操作
Map<Department, Integer> totalSalaries = employees.stream()
.collect(Collectors.groupingBy(
Employee::getDepartment,
Collectors.summingInt(Employee::getSalary)
));
4. 自定义Collector的威力
JAVA
// 自定义复杂收集器
public static <T> Collector<T, ?, Double> averaging(ToDoubleFunction<T> mapper) {
return Collector.of(
() -> new double[2], // [sum, count]
(a, t) -> { a[0] += mapper.applyAsDouble(t); a[1]++; },
(a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
a -> a[1] == 0 ? 0.0 : a[0] / a[1]
);
}
设计哲学的优势：
- 关注点分离：泛型处理类型，函数式接口处理行为
- 编译时类型检查：避免运行时错误
- 方法引用支持：
String::length、ArrayList::new等 - 并行友好：容易实现并行流操作
这种设计让Java在保持强类型语言优势的同时，获得了函数式编程的表达力和简洁性，确实是现代Java最成功的特性之一！
