⚙️ 流式编程核心原理
Java流式编程 基于 Stream API,它并非数据结构,而是对数据源(集合、数组等)进行函数式操作的抽象层。其本质是 内部迭代 与 操作流水线。流操作分为 中间操作(如 filter、map)和 终端操作(如 collect、reduce)。
无存储
流不存储数据,只对源数据施加计算。所有操作延迟执行,直到终端操作触发。
函数式组合
每个中间操作返回新流,形成 流水线。典型:list.stream().filter(x->x>5).map(String::valueOf).collect(...)
惰性求值
中间操作不立即计算,而是构建 操作链。终端操作一次性触发全部计算,避免多次迭代。
| 操作类型 | 示例 | 说明 |
|---|---|---|
| 中间操作 | filter() map() distinct() | 返回新流,可链式调用 |
| 终端操作 | collect() forEach() count() | 触发计算,流被消耗 |
| 短路操作 | findFirst() anyMatch() | 无需遍历全部数据,提升性能 |
// 典型流水线示例(无终端操作不执行)
Stream<String> stream = list.stream()
.filter(s -> s.length() > 3) // 中间操作
.map(String::toUpperCase); // 中间操作
// 此时无任何输出,直到调用 collect()
〓 惰性求值 · 延迟计算
惰性求值 是流式编程的灵魂。中间操作只记录 Lambda 表达式,不遍历元素。终端操作一次性遍历并执行所有操作。这带来两个优势:避免中间状态 和 优化执行计划(如 短路优化)。
① 创建流
Stream.of("a","bb","ccc") 或 collection.stream()
② 中间操作链
.filter(x->x.length()>1) 只记录谓词,不执行。
③ 终端触发
.count() 一次性遍历,同时应用 filter 和 map。
【filter + map】
筛选长度大于2的字符串并转为大写:
List<String> list = List.of("java","流","编程","原理");
list.stream()
.filter(s -> s.length() >= 2)
.map(String::toUpperCase)
.forEach(System.out::println);
// 输出: JAVA 编程 原理
惰性求值 确保只迭代一次。
【flatMap 展平】
将多个流合并为一个流,常用于嵌套集合:
List<List<Integer>> nested = List.of(
List.of(1,2), List.of(3,4,5));
nested.stream()
.flatMap(List::stream)
.map(x -> x * 10)
.collect(Collectors.toList());
// 结果: [10, 20, 30, 40, 50]
【短路 · findFirst】
找到第一个匹配元素即停止,无需遍历全部:
Stream.of("cat","dog","bird")
.filter(s -> s.startsWith("d"))
.findFirst()
.ifPresent(System.out::println);
// 只处理 "dog" 后停止
【】并行流 · 多核加速
并行流 通过 parallelStream() 或 .parallel() 将任务拆分为多个子任务,利用 ForkJoinPool 并行处理。但需注意线程安全及顺序依赖。
拆分策略
基于 Spliterator 将数据源拆分为独立块,每个块由不同线程处理。
适用场景
CPU密集型、大规模数据、无状态操作。避免在并行流中使用有状态 Lambda。
性能陷阱
数据量小或存在频繁装箱时,并行可能更慢。使用 limit() 会降低并行度。
// 并行流示例:累加1~1e7
long sum = LongStream.rangeClosed(1, 10_000_000)
.parallel()
.sum();
// 自动使用多核,但需注意顺序
〔〕收集器与终端操作
Collectors 工具类提供了丰富的归约操作,如 toList()、groupingBy()、partitioningBy()。深入理解 下游收集器 可以极大提升数据处理效率。
| 收集器 | 返回 | 示例 |
|---|---|---|
| toList() | List<T> | collect(Collectors.toList()) |
| groupingBy | Map<K,List<T>> | collect(Collectors.groupingBy(Function)) |
| joining | String | collect(Collectors.joining(", ")) |
【groupingBy 分组】
Map<Integer, List<String>> byLen =
Stream.of("java","stream","api","原理")
.collect(Collectors.groupingBy(String::length));
// {2=[原理], 3=[api], 4=[java], 6=[stream]}
【partitioningBy 分区】
Map<Boolean, List<Integer>> part =
Stream.of(1,2,3,4,5,6)
.collect(Collectors.partitioningBy(x -> x % 2 == 0));
// {false=[1,3,5], true=[2,4,6]}
【自定义收集器】
实现 Collector 接口,用于复杂归约。例如收集为不可变集合:
Collector<T, ?, ImmutableList<T>> toImmutable =
Collector.of(ImmutableList::builder,
ImmutableList.Builder::add,
(b1,b2)-> { b1.addAll(b2.build()); return b1; },
ImmutableList.Builder::build);
★ 网友热问 · 流式编程
※ 深度示例:自定义 Spliterator
实现流拆分逻辑,控制并行粒度。例如按行读取大文件:
class LineSpliterator extends Spliterators.AbstractSpliterator<String> {
private BufferedReader reader;
protected LineSpliterator(BufferedReader r) {
super(Long.MAX_VALUE, Spliterator.ORDERED | Spliterator.NONNULL);
this.reader = r;
}
@Override
public boolean tryAdvance(Consumer<? super String> action) {
try { String line = reader.readLine();
if(line != null) { action.accept(line); return true; }
} catch(IOException e) {}
return false;
}
}