Java基础 - Stream 流：Stream API的终端操作

在前两篇博客中，我介绍了构建 Stream 流的多种方式，以及 Stream API 的中间操作，如果你还没有阅读，你可以点击这里和这里查看。

Java基础 - Stream 流：构建流的多种方式

Java基础 - Stream 流：Stream API的中间操作

在这篇博客中，我将探索 Stream API 的终端操作，它们可以让你从 Stream 流中得到最终的结果，或者产生一些副作用。

Stream API 的终端操作是指那些会消耗 Stream 流，产生一个最终的结果或者一个副作用的操作，它们不能再链式地调用，而是结束一个操作管道。Stream API 提供了很多终端操作，可以分为以下几类：

• 归约：这类操作可以让你将 Stream 流中的所有元素合并为一个值，例如 reduce, sum, max, min, count 等。
• 收集：这类操作可以让你将 Stream 流中的所有元素收集到一个集合或者一个值中，例如 collect, toList, toSet, toMap, joining 等。
• 遍历：这类操作可以让你对 Stream 流中的每个元素执行一个消费者（Consumer）操作，例如 forEach, forEachOrdered 等。
• 匹配：这类操作可以让你判断 Stream 流中的元素是否满足一个条件，例如 anyMatch, allMatch, noneMatch 等。
• 查找：这类操作可以让你从 Stream 流中找到一个元素，例如 findAny, findFirst 等。

下面，我将用一些示例来展示这些终端操作的用法和效果。

1. 归约

1.1 reduce

reduce 操作可以让你将 Stream 流中的所有元素按照一个二元操作（BinaryOperator）进行归约，返回一个 Optional 对象，它可能包含一个值，也可能为空。你也可以指定一个初始值，作为归约的起点。例如：

// 创建一个 Stream 流对象
Stream<Integer> numberStream = Stream.of(1, 2, 3, 4, 5);

// 使用 reduce 操作将所有元素相加，不指定初始值
Optional<Integer> sum1 = numberStream.reduce((a, b) -> a + b);

// 输出 Optional[15]
System.out.println(sum1);

// 使用 reduce 操作将所有元素相加，指定初始值为 0
int sum2 = numberStream.reduce(0, (a, b) -> a + b);

// 输出 15
System.out.println(sum2);

1.2 sum

sum 操作可以让你将 Stream 流中的所有元素相加，返回一个数值。你需要将 Stream 流转换为数值流，例如 IntStream, LongStream, DoubleStream 等。例如：

// 创建一个 Stream 流对象
Stream<Integer> numberStream = Stream.of(1, 2, 3, 4, 5);

// 使用 sum 操作将所有元素相加，需要转换为 IntStream
int sum = numberStream.mapToInt(Integer::intValue).sum();

// 输出 15
System.out.println(sum);

1.3 max

max 操作可以让你从 Stream 流中找到最大的元素，返回一个 Optional 对象，它可能包含一个值，也可能为空。你可以指定一个比较器（Comparator）来定义元素的大小。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 max 操作找到最大的元素，按照自然顺序比较
Optional<String> max1 = animalStream.max(String::compareTo);

// 输出 Optional[yellow]
System.out.println(max1);

// 使用 max 操作找到最大的元素，按照长度比较
Optional<String> max2 = animalStream.max((s1, s2) -> s1.length() - s2.length());

// 输出 Optional[elephant]
System.out.println(max2);

1.4 min

min 操作可以让你从 Stream 流中找到最小的元素，返回一个 Optional 对象，它可能包含一个值，也可能为空。你可以指定一个比较器（Comparator）来定义元素的大小。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 min 操作找到最小的元素，按照自然顺序比较
Optional<String> min1 = animalStream.min(String::compareTo);

// 输出 Optional[cat]
System.out.println(min1);

// 使用 min 操作找到最小的元素，按照长度比较
Optional<String> min2 = animalStream.min((s1, s2) -> s1.length() - s2.length());

// 输出 Optional[cat] 或者 Optional[dog] 或者 Optional[fox]
System.out.println(min2);

1.5 count

count 操作可以让你计算 Stream 流中的元素个数，返回一个长整型。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 count 操作计算元素个数
long count = animalStream.count();

// 输出 5
System.out.println(count);

2. 收集

2.1 collect

collect 操作可以让你将 Stream 流中的所有元素收集到一个集合或者一个值中，返回一个收集结果。你需要指定一个收集器（Collector）来定义收集的规则。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 collect 操作将所有元素收集到一个列表中，使用预定义的收集器
List<String> list = animalStream.collect(Collectors.toList());

// 输出 [cat, dog, elephant, fox, giraffe]
System.out.println(list);

// 使用 collect 操作将所有元素收集到一个字符串中，使用自定义的收集器
String string = animalStream.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append).toString();

// 输出 catdogelephantfoxgiraffe
System.out.println(string);

2.2 toList

toList 操作可以让你将 Stream 流中的所有元素收集到一个列表中，返回一个列表。它是一个预定义的收集器，可以直接使用。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 toList 操作将所有元素收集到一个列表中
List<String> list = animalStream.toList();

// 输出 [cat, dog, elephant, fox, giraffe]
System.out.println(list);

2.3 toSet

toSet 操作可以让你将 Stream 流中的所有元素收集到一个集合中，返回一个集合。它是一个预定义的收集器，可以直接使用。它会去除重复的元素。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "cat", "elephant", "dog", "fox");

// 使用 toSet 操作将所有元素收集到一个集合中
Set<String> set = animalStream.toSet();

// 输出 [cat, dog, elephant, fox]
System.out.println(set);

2.4 toMap

toMap 操作可以让你将 Stream 流中的所有元素收集到一个映射中，返回一个映射。它是一个预定义的收集器，可以直接使用。你需要指定一个键函数（Key Function）和一个值函数（Value Function）来定义映射的键和值。你也可以指定一个合并函数（Merge Function）来处理重复的键。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 toMap 操作将所有元素收集到一个映射中，以元素的首字母为键，以元素的长度为值
Map<String, Integer> map1 = animalStream.collect(Collectors.toMap(s -> s.substring(0, 1), String::length));

// 输出 {c=3, d=3, e=8, f=3, g=7}
System.out.println(map1);

// 使用 toMap 操作将所有元素收集到一个映射中，以元素的长度为键，以元素为值，如果有重复的键，就用逗号连接值
Map<Integer, String> map2 = animalStream.collect(Collectors.toMap(String::length, s -> s, (s1, s2) -> s1 + ", " + s2));

// 输出 {3=cat, dog, fox, 8=elephant, 7=giraffe}
System.out.println(map2);

2.5 joining

joining 操作可以让你将 Stream 流中的所有元素连接成一个字符串，返回一个字符串。它是一个预定义的收集器，可以直接使用。你可以指定一个分隔符（Delimiter）来分隔元素，也可以指定一个前缀（Prefix）和一个后缀（Suffix）来包裹字符串。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 joining 操作将所有元素连接成一个字符串，不指定分隔符，前缀和后缀
String string1 = animalStream.collect(Collectors.joining());

// 输出 catdogelephantfoxgiraffe
System.out.println(string1);

// 使用 joining 操作将所有元素连接成一个字符串，指定分隔符为逗号，前缀为左括号，后缀为右括号
String string2 = animalStream.collect(Collectors.joining(", ", "(", ")"));

// 输出 (cat, dog, elephant, fox, giraffe)
System.out.println(string2);

3. 遍历

3.1 forEach

forEach 操作可以让你对 Stream 流中的每个元素执行一个消费者（Consumer）操作，不返回任何结果。它是一个终端操作，会消耗 Stream 流。它不保证按照数据源的顺序执行，如果需要保证顺序，可以使用 forEachOrdered 操作。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 forEach 操作对每个元素打印一个消息
animalStream.forEach(s -> System.out.println("I like " + s));

// 可能输出 I like fox, I like dog, I like cat, I like elephant, I like giraffe

3.2 forEachOrdered

forEachOrdered 操作可以让你对 Stream 流中的每个元素按照数据源的顺序执行一个消费者（Consumer）操作，不返回任何结果。它是一个终端操作，会消耗 Stream 流。它保证按照数据源的顺序执行，但可能会影响并行性能。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 forEachOrdered 操作对每个元素按照数据源的顺序打印一个消息
animalStream.forEachOrdered(s -> System.out.println("I like " + s));

// 输出 I like cat, I like dog, I like elephant, I like fox, I like giraffe

4. 匹配

4.1 anyMatch

anyMatch 操作可以让你判断 Stream 流中是否有任意一个元素满足一个谓词（Predicate），返回一个布尔值。它是一个短路的终端操作，只要找到一个满足条件的元素就会停止。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 anyMatch 操作判断是否有以 f 开头的元素
boolean hasF = animalStream.anyMatch(s -> s.startsWith("f"));

// 输出 true
System.out.println(hasF);

4.2 allMatch

allMatch 操作可以让你判断 Stream 流中是否所有的元素都满足一个谓词（Predicate），返回一个布尔值。它是一个短路的终端操作，只要找到一个不满足条件的元素就会停止。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 allMatch 操作判断是否所有的元素都包含 a
boolean allA = animalStream.allMatch(s -> s.contains("a"));

// 输出 false
System.out.println(allA);

4.3 noneMatch

noneMatch 操作可以让你判断 Stream 流中是否没有任何一个元素满足一个谓词（Predicate），返回一个布尔值。它是一个短路的终端操作，只要找到一个满足条件的元素就会停止。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 noneMatch 操作判断是否没有以 z 结尾的元素
boolean noZ = animalStream.noneMatch(s -> s.endsWith("z"));

// 输出 true
System.out.println(noZ);

5. 查找

5.1 findAny

findAny 操作可以让你从 Stream 流中找到任意一个元素，返回一个 Optional 对象，它可能包含一个值，也可能为空。它是一个短路的终端操作，只要找到一个元素就会停止。它不保证返回第一个元素，如果需要保证顺序，可以使用 findFirst 操作。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 findAny 操作找到任意一个元素
Optional<String> anyAnimal = animalStream.findAny();

// 输出 Optional[cat] 或者其他值
System.out.println(anyAnimal);

5.2 findFirst

findFirst 操作可以让你从 Stream 流中找到第一个元素，返回一个 Optional 对象，它可能包含一个值，也可能为空。它是一个短路的终端操作，只要找到第一个元素就会停止。它保证返回第一个元素，但可能会影响并行性能。例如：

// 创建一个 Stream 流对象
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 findFirst 操作找到第一个元素
Optional<String> firstAnimal = animalStream.findFirst();

// 输出 Optional[cat]
System.out.println(firstAnimal);

​