在 Java 中，涉及到对数组 、Collection等集合类中的元素进行操作的时候，通常会通过循环的方式进行逐个处理，或者是使用Stream的方式进行处理。
先看个示例，从给定句子中返回单词长度大于5的单词列表，按长度从大到小排序，最多返回3个：
public static List<String> sortGetTop3LongWordsByStream(@NotNull String sentence){
return Arrays.stream(sentence.split(" "))
.filter(word -> word.length() > 5)
.sorted(((o1, o2) -> o2.length() - o1.length()))
.limit(3)
.collect(Collectors.toList());
}
1. Stream 初相识
概括讲，可以将 Stream 流操作分为 3 种类型：
- 创建 Stream。
- Stream 中间处理。
- 终止 Steam。
每个 Stream 管道操作类型都包含若干 API 方法，先列举下各个 API 方法的功能介绍。
1.1. 开始管道
主负责新建一个 Stream 流，或者基于现有的数组、List、Set、Map 等集合类型对象创建出新的 Stream 流。
| API | 功能说明 |
|---|---|
| stream() | 创建出一个新的 Stream 串行流对象 |
| Stream.of() | 通过给定的一系列元素创建一个新的 Stream 串行流对象 |
| parallelStream() | 创建出一个可并行执行的 Stream 流对象 |
1.2. 中间管道
负责对 Stream 进行处理操作，并返回一个新的 Stream 对象，中间管道操作可以进行叠加 。
| API | 功能说明 |
|---|---|
| filter() | 按照条件过滤符合要求的元素，返回新的 Stream 流 |
| map() | 将已有元素转换为另一个对象类型，一对一逻辑，返回新的 Stream 流 |
| flatMap() | 将已有元素转换为另一个对象类型，一对多逻辑，即原来一个元素对象可能会转换为一个或者多个新类型的元素，返回新的 Stream 流 |
| limit() | 仅保留集合前面指定个数的元素，返回新的 Stream 流 |
| skip() | 跳过集合前面指定个数的元素，返回新的 Stream 流 |
| concat() | 将两个流的数据合并起来为一个新的流，返回新的 Stream 流 |
| distinct() | 对 Stream 流中所有元素进行去重，返回新的 Stream 流 |
| sorted() | 对 Stream 流中所有的元素按照指定规则进行排序，返回新的 Stream 流 |
| peek() | 对 Stream 流中的每个元素进行逐个遍历处理，返回处理后的 Stream 流 |
1.3. 终止管道
顾名思义，通过终止管道操作之后，Stream 流将会结束，最后可能会执行某些逻辑处理，或者是按照要求返回某些执行后的结果数据。
| API | 功能说明 |
|---|---|
| count() | 返回 Stream 处理后最终的元素个数 |
| max() | 返回 Stream 处理后的元素最大值 |
| min() | 返回 Stream 处理后的元素最小值 |
| findFirst() | 找到第一个符合条件的元素时则终止流处理 |
| findAny() | 找到任何一个符合条件的元素时则退出流程处理，这个对于串行流时与 findFirst() 相同，对于并行流时比较高效，任何分片中找到都会终止后续计算逻辑 |
| anyMatch() | 返回一个 boolean 值，类似于 isContains()，用于判断是否有符合条件的元素 |
| allMatch() | 返回一个 boolean 值，用于判断是否所有元素都符合条件 |
| noneMatch() | 返回一个 boolean 值，用于判断是否所有元素都不符合条件 |
| collect() | 将流转换为指定的类型，通过 Collectors 进行指定 |
| toArray() | 将流程转换为数组 |
| iterator() | 将流转换为 Iterator 对象 |
| foreach() | 无返回值，对元素进行逐个遍历，然后执行给定的处理逻辑 |
2. Stream 方法使用
2.1. map 与 flatMap
map 与 flatMap 都属于中间方法，都是用于转换已有的元素为其它元素，区别点在于：
- map 必须是一对一的，即每个元素都只能转换为一个新的元素。
- flatMap 可以是一对多的，即每个元素都可以转换为一个或者多个新的元素。
比如：有一个字符串 ID 列表，现在需要将其转为 User 对象列表 。可以使用 map 来实现：
/**
* 演示map的用途：一对一转换
*/
public static void stringToIntMap() {
List<String> ids = Arrays.asList("205","105","308","469","627","193","111");
// 使用流操作
List<User> results = ids.stream()
.map(s -> User.builder().id(Integer.valueOf(s)).build())
.collect(Collectors.toList());
System.out.println(results);
}
@Data
@Builder
class User {
private Integer id;
}
执行之后，会发现每一个元素都被转换为对应新的元素，但是前后总元素个数是一致的：
[User(id=205), User(id=105), User(id=308), User(id=469), User(id=627), User(id=193), User(id=111)]
再比如：现有一个句子列表，需要将句子中每个单词都提取出来得到一个所有单词列表 。这种情况用 map 就搞不定了，需要 flatMap 上场了：
/**
* 演示flatMap的用途：一对多转换
*/
public static void stringToIntFlatmap() {
List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
// 使用流操作
List<String> results = sentences.stream()
.flatMap(sentence -> Arrays.stream(sentence.split(" ")))
.collect(Collectors.toList());
System.out.println(results);
}
执行结果如下，可以看到结果列表中元素个数是比原始列表元素个数要多的：
[hello, world, Jia, Gou, Wu, Dao]
这里需要补充一句，flatMap 操作的时候其实是先每个元素处理并返回一个新的 Stream，然后将多个 Stream 展开合并为了一个完整的新的 Stream，如下：
2.2. peek 和 foreach
peek 和 foreach，都可以用于对元素进行遍历然后逐个的进行处理。
但根据前面的介绍， peek 属于中间方法 ，而 foreach 属于终止方法 。这也就意味着 peek 只能作为管道中途的一个处理步骤，而没法直接执行得到结果，其后面必须还要有其它终止操作才会被执行；而 foreach 作为无返回值的终止方法，则可以直接执行相关操作。
public static void testPeekAndForeach() {
List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
// 演示点1： 仅peek操作，最终不会执行
System.out.println("----before peek----");
sentences.stream().peek(sentence -> System.out.println(sentence));
System.out.println("----after peek----");
// 演示点2： 仅foreach操作，最终会执行
System.out.println("----before foreach----");
sentences.stream().forEach(sentence -> System.out.println(sentence));
System.out.println("----after foreach----");
// 演示点3： peek操作后面增加终止操作，peek会执行
System.out.println("----before peek and count----");
//JDK8执行，JDK11不执行
sentences.stream().peek(sentence -> System.out.println(sentence)).count();
//JDK8和JDK11都执行
//sentences.stream().peek(sentence -> System.out.println(sentence)).collect(Collectors.toList());
System.out.println("----after peek and count----");
}
输出结果可以看出，peek 独自调用时并没有被执行，但 peek 后面加上终止操作之后便可以被执行，而 foreach 可以直接被执行：
----before peek----
----after peek----
----before foreach----
hello world
Jia Gou Wu Dao
----after foreach----
----before peek and count----
hello world
Jia Gou Wu Dao
----after peek and count----
2.3. filter、sorted、distinct、limit
这几个都是常用的 Stream 的中间操作方法，具体的方法含义在上面的表格里面有说明。使用的时候，可以根据需要选择一个或者多个进行组合使用，或者同时使用多个相同方法的组合：
public static void testGetTargetUsers() {
List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
// 使用流操作
List<Dept> results = ids.stream()
// 使用 filter 过滤掉不符合条件的数据
.filter(s -> s.length() > 2)
// 通过 distinct 对存量元素进行去重操作
.distinct()
// 通过 map 操作将字符串转成整数类型
.map(Integer::valueOf)
//借助 sorted 指定按照数字从小到大正序排列
.sorted(Comparator.comparingInt(o -> o))
// 使用 limit 截取排在前3位的元素
.limit(3)
// 又一次使用 map 将 id 转为 Dept 对象类型
.map(Dept::new)
// 使用 collect 终止操作将最终处理后的数据收集到 list 中
.collect(Collectors.toList());
System.out.println(results);
}
@Data
@AllArgsConstructor
class Dept {
private Integer id;
}
输出结果：
[Dept(id=111), Dept(id=193), Dept(id=205)]
2.4. 简单结果终止方法
按照前面介绍的，终止方法里面像 count、 max、 min、 findAny、 findFirst、 anyMatch、 allMatch、 nonneMatch 等方法，均属于这里说的简单结果终止方法。所谓简单，指的是其结果形式是数字、布尔值或者 Optional 对象值等。
public static void testSimpleStopOptions() {
List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
// count 统计 Stream 操作后剩余的元素个数
System.out.println(ids.stream().filter(s -> s.length() > 2).count());
// anyMatch 判断是否有元素值等于 205
System.out.println(ids.stream().filter(s -> s.length() > 2).anyMatch("205"::equals));
// findFirst操作，找到第一个长度大于 2 的值
ids.stream().filter(s -> s.length() > 2)
.findFirst()
.ifPresent(s -> System.out.println("findFirst: " + s));
}
输出结果：
6
true
findFirst: 205
避坑提醒
这里需要补充提醒下， 一旦一个 Stream 被执行了终止操作之后，后续便不可以再读这个流执行其他的操作了，否则会报错，看下面示例：
public static void testHandleStreamAfterClosed() {
List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
Stream<String> stream = ids.stream().filter(s -> s.length() > 2);
// 统计 Stream 操作后剩余的元素个数
System.out.println(stream.count());
System.out.println("-----下面会报错-----");
// 判断是否有元素值等于 205
try {
System.out.println(stream.anyMatch("205"::equals));
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("-----上面会报错-----");
}
执行的时候，结果如下：
6
-----下面会报错-----
java.lang.IllegalStateException: stream has already been operated upon or closed
at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
at java.util.stream.ReferencePipeline.anyMatch(ReferencePipeline.java:449)
at com.example.demo.stream.Test.testHandleStreamAfterClosed(Test.java:29)
at com.example.demo.stream.Test.main(Test.java:18)
-----上面会报错-----
因为 Stream 已经被执行 count() 终止方法了，所以对 Stream 再执行 anyMatch() 方法的时候，就会报错stream has already been operated upon or closed，这一点在使用的时候需要特别注意。
2.5. 结果收集终止方法
因为 Stream 主要用于对集合数据的处理场景，所以除了上面几种获取简单结果的终止方法之外，更多的场景是获取一个集合类的结果对象，比如 List、Set 或者 HashMap 等。
这里就需要 collect 方法出场了，它可以支持生成如下类型的结果数据：
- 集合类
- 字符串进行拼接
- 数据批量运算统计
2.5.1. 生成集合
应该算是 collect 最常被使用到的一个场景了：
public static void testCollectStopOptions() {
List<Dept> ids = Arrays.asList(new Dept(17), new Dept(22), new Dept(23));
// collect 成 list
List<Dept> collectList = ids.stream().filter(dept -> dept.getId() > 20).collect(Collectors.toList());
System.out.println("collectList:" + collectList);
// collect 成 Set
Set<Dept> collectSet = ids.stream().filter(dept -> dept.getId() > 20).collect(Collectors.toSet());
System.out.println("collectSet:" + collectSet);
// collect 成 HashMap，key 为 id，value 为 Dept 对象
Map<Integer, Dept> collectMap = ids.stream().filter(dept -> dept.getId() > 20).collect(Collectors.toMap(Dept::getId, dept -> dept));
System.out.println("collectMap:" + collectMap);
// 等价写法，性能更好
Map<Integer, Dept> collectMap1 = ids.stream().filter(dept -> dept.getId() > 20).collect(Collectors.toMap(Dept::getId, Function.identity()));
System.out.println("collectMap1:" + collectMap1);
}
结果如下：
collectList:[Dept(id=22), Dept(id=23)]
collectSet:[Dept(id=22), Dept(id=23)]
collectMap:{22=Dept(id=22), 23=Dept(id=23)}
collectMap1:{22=Dept(id=22), 23=Dept(id=23)}
注意事项：
-
Collectors.toList() 允许流中存在 null 值，它会将 null 元素收集到返回的 List 中，收集后的 List 若包含 null，遍历或调用方法时可能触发 NullPointerException，所以使用的时候最好是通过 filter 提前排除 null 元素，可避免后续风险。
若流无元素，返回的是空 List（非 null）。 -
Collectors.toSet() 允许流中存在 null 值，它会将 null 元素收集到返回的 Set 中，收集后的 Set 若包含 null，遍历或调用方法时可能触发 NullPointerException，所以使用的时候最好是通过 filter 提前排除 null 元素，可避免后续风险。
若流无元素，返回的是空 Set（非 null）。
依赖具体 Set 实现的行为：HashSet/LinkedHashSet 允许单个 null 值；TreeSet 等排序集合会因 null 抛出 NullPointerException（排序时无法比较）。 -
Collectors.toMap(k, v)，这里的 k 和 v 都不允许为 NULL 值，否则会报空指针 NPE(NullPointerException)。所以使用的时候要注意提前加 filter 或 null 值判断和转换。
HashMap 本身支持 null 键值，但 toMap() 因依赖 merge() 方法而强制禁止，若需保留 null，必须改用其他方案。
若流无元素，返回的是空 HashMap（非 null）。
Collectors.toMap(k, v) 的 k 冲突（重复），若未指定合并函数，遇到重复 Key 会直接抛出 IllegalStateException。可以通过第三个参数定义冲突解决策略（合并函数（Merge Function））来处理冲突：
// 1. 保留旧值
Map<String, String> map = list.stream()
.collect(Collectors.toMap(
User::getName,
User::getAge,
(oldVal, newVal) -> oldVal // 冲突时保留原有值
));
// 2. 覆盖为新值
Map<String, String> map = list.stream()
.collect(Collectors.toMap(
User::getName,
User::getAge,
(oldVal, newVal) -> newVal // 冲突时使用新值
));
// 3. 合并值（如拼接字符串）
Map<String, String> map = list.stream()
.collect(Collectors.toMap(
User::getName,
User::getAge,
(v1, v2) -> v1 + ", " + v2 // 将冲突值连接
));
// 4. 转为集合存储
Map<Integer, List<String>> map = list.stream()
.collect(Collectors.toMap(
User::getId,
user -> new ArrayList<>(List.of(user.getName())),
(list1, list2) -> { list1.addAll(list2); return list1; }
));
// 5. 自定义 Map 实现：通过第四个参数指定具体 `Map` 类型（如 `LinkedHashMap` 保持插入顺序）
Map<String, String> map = list.stream()
.collect(Collectors.toMap(
User::getName,
User::getAge,
(v1, v2) -> v1,
LinkedHashMap::new
));
// 6. 替代方案
// groupingBy：将相同 Key 的值分组到 List 中
Map<String, List<User>> groupMap = list.stream()
.collect(Collectors.groupingBy(User::getName));
// 手动构建 Map：通过 forEach 灵活控制冲突逻辑
Map<String, String> manualMap = new HashMap<>();
list.forEach(user -> manualMap.merge(user.getName(), user.getAge(), (oldVal, newVal) -> newVal));
2.5.2. 生成拼接字符串
将一个 List 或者数组中的值拼接到一个字符串里并以逗号分隔开，这个场景相信大家都不陌生吧？
如果通过 for 循环和 StringBuilder 去循环拼接，还得考虑下最后一个逗号如何处理的问题，很繁琐，但是现在有了 Stream，使用 collect 可以轻而易举的实现：
public static void testCollectJoinStrings() {
List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
String joinResult = ids.stream().filter(i -> i.length() > 2).collect(Collectors.joining(","));
System.out.println("拼接后：" + joinResult);
}
输出：
拼接后：205,308,627,193,111,193
2.5.3. 数据批量数学运算
还有一种场景，实际使用的时候可能会比较少，就是使用 collect 生成数字数据的总和信息，也可以了解下实现方式：
public static void testNumberCalculate() {
List<Integer> ids = Arrays.asList(10, 20, 30, 40, 50);
// 计算平均值
Double average = ids.stream().collect(Collectors.averagingInt(value -> value));
System.out.println("平均值：" + average);
// 数据统计信息
IntSummaryStatistics summary = ids.stream().collect(Collectors.summarizingInt(value -> value));
System.out.println("数据统计信息： " + summary);
}
上面的例子中，使用 collect 方法来对 list 中元素值进行数学运算，结果如下：
平均值：30.0
数据统计信息： IntSummaryStatistics{count=5, sum=150, min=10, average=30.000000, max=50}
3. 并行 Stream
3.1. 机制说明
使用并行流，可以有效利用计算机的多 CPU 硬件，提升逻辑的执行速度。并行流通过将一整个 Stream 划分为多个片段，然后对各个分片流并行执行处理逻辑，最后将各个分片流的执行结果汇总为一个整体流。
3.2. 约束与限制
并行流类似于多线程在并行处理，所以与多线程场景相关的一些问题同样会存在，比如死锁等问题，所以在并行流终止执行的函数逻辑，必须要保证线程安全。
4. Stream 的优缺点
根据前面的介绍，我们应该可以得出如下几点答案：
- 代码更简洁，偏声明式的编码风格，更容易体现出代码的逻辑意图。
- 逻辑间解耦，一个 Stream 中间处理逻辑，无需关注上游与下游的内容，只需要按约定实现自身逻辑即可。
- 并行流场景效率会比迭代器逐个循环更高。
- 函数式接口，延迟执行的特性，中间管道操作不管有多少步骤都不会立即执行，只有遇到终止操作的时候才会开始执行，可以避免一些中间不必要的操作消耗。
当然了，Stream 也不全是优点，在有些方面也有其弊端：
- 代码调测 debug 不方便。
- 程序员从历史写法切换到 Stream 时，需要一定的适应时间。
