当前位置： 首页 > news >正文

16-集合的Stream编程

news 2025/8/17 9:59:01

一 Stream编程简介

Stream编程（也叫集合的流式编程），是JDK1.8引入的新特性，也是JDK1.8新特性中最值得学习的两种新特性之一。（另外一个是 lambda表达式）。

Stream是对集合操作的增强，Stream不是一种数据结构，不负责数据的存储。流更像是一个迭代器，可以单向的遍历一个集合中的每一个元素，并且不可循环。

为什么要引入这个特性呢？

有些时候，对集合中的元素进行操作的时候，需要使用到其他操作的结果。在这个过程中，集合的流式 编程可以大幅度的简化代码的数量。将数据源中的数据，读取到一个流中，可以对这个流中的数据进行 操作（删除、过滤、映射…）。每次的操作结果也是一个流对象，可以对这个流再进行其他的操作。

二 Stream编程步骤

通常情况下，对集合中的数据使用流式编程，需要经过以下三步。

  1. 获取数据源，将数据源中的数据读取到流中。
  2. 对流中的数据进行各种各样的处理。
  3. 对流中的数据进行整合处理。

在上述三个过程中，

过程2中，有若干方法，可以对流中的数据进行各种各样的操作，并且返回流对象 本身，这样的操作，被称为 – 中间操作。

过程3中，有若干方法，可以对流中的数据进行各种处理，并关闭流，这样的操作，被称为 – 最终操作。

在中间操作和最终操作中，基本上所有的方法参数都是函数式接口，可以使用lambda表达式来实现。 使用集合的流式编程，来简化代码量，是需要对 lambda 表达式做到熟练掌握。

三 数据源的获取

数据源，顾名思义，既是流中的数据的来源。 集合的流式编程的第一步，将数据源中的数据读取到流中，进行处理。这个过程，其实是将一个容器中的数据，读取到一个流中。因此无论什么容器作为数据源，读取到流中的方法返回值一定是一个Stream。

// 1、通过Collection接口中的stream()方法获取数据源为Collection的流
Stream<Integer> stream = list.stream();
// 2、通过Collection接口的parallelStream()方法获取数据源为Collection的流
Stream<Integer> stream = list.parallelStream();
// 3、通过Arrays工具类中的stream()方法获取数据源为数组的流
IntStream stream = Arrays.stream(array);

stream() 和 parallelStream的比较：

  • 他们都是Collection集合获取数据源的方法，
  • 不同点在于stream()方法获取的数据源是串行的，parallelStream()获取的数据源是并行的。 parallelStream()内部集成了多个线程对流中的数据进行操作，效率更高。

注意：

将数据读取到流中进行处理的时候，与数据源中的数据没有关系。也就是说，中间操作对流中的数据进行处理、过滤、映射、排序… ，此时是不会影响数据源中的数据的

四 最终操作方法

将流中的数据整合到一起，可以存入一个集合，也可以直接对流中的数据进行遍历、数据统计… ，通过最终操作，需要掌握如何从流中提取出来我们想要的信息。

注意事项：

最终操作，之所以叫最终操作，是因为，在最终操作执行结束后，会关闭这个流，流中的所有数据都会销毁。如果使用一个已经关闭了的流，会出现异常。

4.1 collect方法

将流中的数据收集到一起，对这些数据进行一些处理。最常见的处理，就是将流中的数据存入一个集 合。 collect方法的参数，是一个Collector接口，而且这个接口并不是一个函数式接口。实现这个接口， 可以自定义收集的规则。但是，绝大部分情况下，不需要自定义，直接使用Collectors工具类提供的方法即可

// 1.1、转成  List
List<Integer> result1 = list.stream().collect(Collectors.toList());
System.out.println(result1);// 1.2、转成  Set
Set<Integer> result2 = list.stream().collect(Collectors.toSet());
System.out.println(result2);// 1.3、转成  Map，提供两个函数式接口的实现，分别实现键的生成规则和值的生成规则
Map<Integer, Integer> result3 = list.stream().collect(Collectors.toMap(ele ->ele / 10, ele -> ele));
System.out.println(result3);

toMap方法源码解析

public static <T, K, U>  Collector<T, ?, Map<K,U>>   toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {return new CollectorImpl<>(HashMap::new,uniqKeysMapAccumulator(keyMapper, valueMapper),uniqKeysMapMerger(),CH_ID);
}参数源码解析：
1. 查看Function源码，@FunctionalInterfacepublic interface Function<T, R> {R apply(T t);//...省略...}结论： 其实就是使用lambda表达式，实现apply方法的匿名写法。使用时如下： x 和 y都是指向的元素本身，toMap( x-> {...}, y->{...})

4.2 reduce方法

将流中的数据按照一定的规则聚合起来。

// 将流的元素，逐一带入到这个方法中，进行运算
// 最终的运算结果，得到的其实是一个  Optional 类型，需要使用get() 获取到里面的数据
int result4 = list.stream().reduce((e1, e2) -> e1 + e2).get();
System.out.println(result4);

4.3 count

统计流中的元素数量。

long result5 = list.stream().count();
System.out.println(result5);

4.4 forEach

迭代、遍历流中的数据。

list.stream().forEach(System.out::println);

4.5 max & min

获取流中的最大的元素、最小的元素。

// 获取最大值
Integer result6 = list.stream().max(Integer::compareTo).get();
System.out.println("max is : " + result6);
// 获取最小值
Integer result7 = list.stream().min(Integer::compareTo).get();
System.out.println("min is : " + result7);

4.6 Matching

  • allMatch: 只有当流中所有的元素，都匹配指定的规则，才会返回 true
  • anyMatch: 只要流中有任意的数据，满足指定的规则，都会返回 true
  • noneMatch: 只有当流中的所有的元素，都不满足指定的规则，才会返回true
// 判断流中是否所有的元素都大于  50
boolean result8 = list.stream().allMatch(ele -> ele > 50);
System.out.println(result8);// 判断流中是否有大于  50 的数据
boolean result9 = list.stream().anyMatch(ele -> ele > 50);
System.out.println(result9);// 判断流中是否没有奇数
boolean result10 = list.stream().noneMatch(ele -> ele % 2 != 0);
System.out.println(result10);

4.7 find

  • findFirst: 从流中获取一个元素（一般情况下，是获取的开头的元素）
  • findAny: 从流中获取一个元素（一般情况下，是获取的开头的元素）

这两个方法，绝大部分情况下，是完全相同的，但是在多线程的环境下， findAny和findFirst返回的结果可能不一样。

Integer result11 = list.parallelStream().findFirst().get();
System.out.println(result11);Integer result12 = list.parallelStream().findAny().get();
System.out.println(result12);

4.8 最终操作的注意事项

最终操作，会关闭流。如果一个流被关闭了，再去使用这个流，就出出现异常。

// 9、最终操作错误示范
Stream<Integer> stream = list.stream();
long count = stream.count();
stream.forEach(System.out::println);
Exception in thread "main" java.lang.IllegalStateException: stream has already
been operated upon or closed
at
java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java
:279)
at
java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
at com.qf.cstream.FinalOperationDemo.main(FinalOperationDemo.java:78)

五 中间操作方法

5.1 filter

5.2 distinct

5.3 sorted

5.4 limit & skip

5.5 map & flatMap

5.6 mapToInt

六 工具类

Collectors是一个工具类，里面封装了很多方法，可以很方便的获取到一个 Collector 接口的实现类对 象，从而可以使用 collect() 方法，对流中的数据，进行各种各样的处理、整合。

Collectors.toList() : 将流中的数据，聚合到一个  List 集合中 
Collectors.toSet()  : 将流中的数据，聚合到一个  Set 集合中   
Collectors.toMap()  : 将流中的数据，聚合到一个  Map 集合中
maxBy()             : 按照指定的规则，找到流中最大的元素，等同于  max
minBy()             : 按照指定的规则，找到流中最小的元素，等同于  minjoining()           : 将流中的数据拼接成一个字符串，注意：只能操作流中是String的数据summingInt()        : 将流中的数据，映射成  int 类型的数据，并求和
averagingInt()      : 将流中的数据，映射成  int 类型的数据，并求平均值
summarizingInt()    : 将流中的数据，映射成  int 类型的数据，并获取描述信息
// maxBy: 按照指定的规则，找到流中最大的元素，等同于  max
Student max = list.stream().collect(Collectors.maxBy((s1, s2) -> s1.getScore() -s2.getScore())).get();
System.out.println(max);// minBy: 按照指定的规则，找到流中最小的元素，等同于  min
Student min = list.stream()
.collect(Collectors.minBy((s1, s2) -> s1.getScore() -s2.getScore()))
.get();
System.out.println(min);// 将流中的数据，拼接起来
String s1 = list.stream().map(Student::getName).collect(Collectors.joining());
System.out.println(s1);// 将流中的数据，拼接起来，以指定的分隔符进行分隔
String s2 = list.stream().map(Student::getName).collect(Collectors.joining(", "));
System.out.println(s2);// 将流中的数据，拼接起来，以指定的分隔符进行分隔，并添加前缀和尾缀
String s3 = list.stream().map(Student::getName).collect(Collectors.joining(", ", "{", "}"));
System.out.println(s3);// 将流中的数据，映射成  int 类型的数据，并求和
int sum = list.stream().collect(Collectors.summingInt(Student::getScore));
System.out.println(sum);// 将流中的数据，映射成  int 类型的数据，并求平均值
double average = list.stream().collect(Collectors.averagingInt(Student::getScore));
System.out.println(average);// 将流中的数据，映射成 int 类型的数据，并获取描述信息
IntSummaryStatistics summaryStatistics = list.stream().collect(Collectors.summarizingInt(Student::getScore));System.out.println(summaryStatistics);
System.out.println(summaryStatistics.getCount());
System.out.println(summaryStatistics.getSum());
System.out.println(summaryStatistics.getMax());
System.out.println(summaryStatistics.getMin());
System.out.println(summaryStatistics.getAverage());

七 练习题

需求 : 一个集合中存储了了若干个Student对象 , 要求查询出以下结果 :

  1. 所有及格的学生信息
  2. 所有及格的学生姓名
  3. 所有学生的平均成绩
  4. 班级的前3名(按照成绩)
  5. 班级的3-10名(按照成绩)
  6. 所有不不及格的学生平均成绩
  7. 将及格的学生 , 按照成绩降序输出所有信息
  8. 班级学生的总分
public static void main(String[] args) {List<Student> list = new ArrayList<Student>();Student s1 = new Student("小王",'M',99.0);Student s2 = new Student("小李",'M',50.0);Student s3 = new Student("小胡",'M',80.0);Student s4 = new Student("小周",'M',75.0);Student s5 = new Student("小唐",'M',80.0);Student s6 = new Student("小雷",'M',85.0);Student s7 = new Student("小陈",'M',45.0);Student s8 = new Student("小赵",'M',65.0);Student s9 = new Student("小钱",'M',55.0);Student s10 = new Student("小明",'M',100.0);list.addAll(Arrays.asList(s1,s2,s3,s4,s5,s6,s7,s8,s9,s10));Stream<Student> st = list.stream();//需求：1. 所有及格的学生信息List<Student> students = st.filter(e -> e.getScore() >= 60).collect(Collectors.toList());System.out.println(students);//需求：2. 所有及格的学生姓名List<String> students = st.filter(e -> e.getScore() >= 60).map(Student::getNeme).collect(Collectors.toList());System.out.println(students);//需求：所有学生的平均成绩double average = st.mapToDouble((x) -> x.getScore()).summaryStatistics().getAverage();System.out.println(average);//74.4//需求：班级的前3名(按照成绩)List<String> list1 = st.sorted(Comparator.comparingDouble(Student::getScore).reversed()).limit(3).map(Student::getNeme).toList();System.out.println(list1);//需求：班级的3-10名(按照成绩)List<String> list1 = st.sorted(Comparator.comparingDouble(Student::getScore).reversed()).skip(2).limit(8).map(Student::getNeme).toList();System.out.println(list1);//需求：所有不不及格的学生平均成绩Double v = st.filter(x -> x.getScore() < 60).collect(Collectors.averagingDouble(x -> x.getScore()));System.out.println(v);//50.0//需求：将及格的学生 , 按照成绩降序输出所有信息List<Student> list1 = st.filter(x -> x.getScore() >= 60).sorted(Comparator.comparingDouble(Student::getScore).reversed()).toList();System.out.println(list1);//需求：班级学生的总分Double sumScore = st.collect(Collectors.summingDouble((x) -> x.getScore()));System.out.println(sumScore);//744.0}
http://www.dtcms.com/a/334920.html

相关文章：

  • 基于STM32的智能书房系统设计与实现
  • BitLocker解密
  • docker compose安装mysql8
  • UE5多人MOBA+GAS 46、制作龙卷风技能
  • C/单片机内存管理，仿真keii
  • 第5问 对于数据分析领域，统计学要学到什么程度？
  • 第6问 数据分析领域主要的岗位有哪些？
  • 《从混乱到有序：AI 如何一步步梳理数据质量难题》文章提纲
  • 基于Python的课程作业管理系统 Python+Django+Vue.js
  • Python-深度学习.pytorch（二）——自动微分、认识深度学习
  • C++STL标准模板库详解
  • 【渗透实战】无下载器环境(curl/wget)下玩转 Metasploit 自动利用
  • ES操作手册
  • 一、内核初始化中与内存管理相关的函数
  • C语言：文件操作详解
  • 微软Wasm学习-创建一个最简单的c#WebAssembly测试工程
  • 【项目实战】利用AI生成式编程生成控制镜头变倍，变焦，光圈的Shell脚本（一）
  • 如何在FastAPI中玩转APScheduler，实现动态定时任务的魔法？
  • Redis7学习--详解 主从复制
  • 利用cursor+MCP实现浏览器自动化释放双手
  • 自动驾驶中的传感器技术24.1——Camera（16）
  • 企业级Java项目金融应用领域——银行系统（补充）
  • python线程学习
  • 一文了解金融合规
  • 什么是模型预测控制？
  • 算法训练营day52 图论③ 101.孤岛的总面积、102.沉没孤岛、103.水流问题、104.建造最大岛屿
  • PTPX分析中，如何处理fsdb文件过大的问题？
  • 【C#补全计划】Lambda表达式
  • ESP32-S3_ES8311音频输出使用
  • java内存模型：