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);

  • 15
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

--土拨鼠--

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值