在前两篇博客中,我介绍了构建 Stream 流的多种方式,以及 Stream API 的中间操作,如果你还没有阅读,你可以点击这里和这里查看。
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);