超详细的Java8 Stream使用方法：筛选、排序、最大值、最小值、计数求和平均数、分组、合并、映射、去重等

已于 2023-07-27 11:38:46 修改
阅读量2.2w 收藏 114
点赞数 22
分类专栏： java # JDK版本新特性 文章标签： java 1024程序员节
于 2022-04-11 11:08:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HO1_K/article/details/124044607
版权

前言

本文主要介绍Stream流操作的常用使用方法，也算是在日常工作中，对流和函数式编程的用法总结。



目录

文章目录




前置数据

初始化队列数据：

List<Student> students = Stream.of(
        Student.builder().name("小张").age(16).clazz("高一1班").course("历史").score(88).build(),
        Student.builder().name("小李").age(16).clazz("高一3班").course("数学").score(12).build(),
        Student.builder().name("小王").age(17).clazz("高二1班").course("地理").score(44).build(),
        Student.builder().name("小红").age(18).clazz("高二1班").course("物理").score(67).build(),
        Student.builder().name("李华").age(15).clazz("高二2班").course("数学").score(99).build(),
        Student.builder().name("小潘").age(19).clazz("高三4班").course("英语").score(100).build(),
        Student.builder().name("小聂").age(20).clazz("高三4班").course("物理").score(32).build()
).collect(Collectors.toList());




用法实例

检视流中的元素

如果我们需要在流式操作中查看某个环节的元素情况，或者修改流中的某个数据项，就可以通过peek检视元素。

语法：

Stream peek(Consumer<? super T> action)

用例：

// 检视元素
List<String> peek = students.stream()
        .filter(s -> s.getScore() > 60)
        .peek(System.out::println)
        // peek还可以用来修改元素内容
        //.peek(s -> s.setScore(60))
        .map(Student::getName)
        .peek(System.out::println)
        .collect(Collectors.toList());
System.out.println(peek);

结果：

Student(name=小张, age=16, clazz=高一1班, score=88, course=历史)
小张
Student(name=小红, age=18, clazz=高二1班, score=67, course=物理)
小红
Student(name=李华, age=15, clazz=高二2班, score=99, course=数学)
李华
Student(name=小潘, age=19, clazz=高三4班, score=100, course=英语)
小潘
[小张, 小红, 李华, 小潘]



流转集合，合并元素

语法：

<R, A> R collect(Collector<? super T, A, R> collector)

<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner)

  • supplier：无参构造器，提供一个无参初始化容器的方法
  • accumulator：累加器，提供容器增加元素的方法
  • combiner：合并函数，提供一个容器合并的方法（因为流内部会使用并行的方式，多个线程会创建多个容器添加元素，以提高执行效率）

用例：

// 流转集合
List<Student> studentList = students.stream().collect(Collectors.toList());
// 使用该方法，可以把流转map或任意集合对象
HashMap<String, Student> map = students.stream().collect(HashMap::new, (hashMap, student) -> hashMap.put(student.getName(), student), HashMap::putAll);
System.out.println(studentList);
System.out.println(map);

结果：

[Student(name=小张, age=16, clazz=高一1班, score=88, course=历史), Student(name=小李, age=16, clazz=高一3班, score=12, course=数学), Student(name=小王, age=17, clazz=高二1班, score=44, course=地理), Student(name=小红, age=18, clazz=高二1班, score=67, course=物理), Student(name=李华, age=15, clazz=高二2班, score=99, course=数学), Student(name=小潘, age=19, clazz=高三4班, score=100, course=英语), Student(name=小聂, age=20, clazz=高三4班, score=32, course=物理)]

{小潘=Student(name=小潘, age=19, clazz=高三4班, score=100, course=英语), 小李=Student(name=小李, age=16, clazz=高一3班, score=12, course=数学), 小王=Student(name=小王, age=17, clazz=高二1班, score=44, course=地理), 小红=Student(name=小红, age=18, clazz=高二1班, score=67, course=物理), 小聂=Student(name=小聂, age=20, clazz=高三4班, score=32, course=物理), 小张=Student(name=小张, age=16, clazz=高一1班, score=88, course=历史), 李华=Student(name=李华, age=15, clazz=高二2班, score=99, course=数学)}



映射

语法：

Stream map(Function<? super T, ? extends R> mapper)
提供一个方法，该方法的返回值将作为流的操作元素

IntStream mapToInt(ToIntFunction<? super T> mapper)
mapToInt和mapToDouble是用于操作整型和浮点型的元素并提供了计数求和求平均值等算术操作，如果要操作流，需要装箱boxed()

DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)

用例：

// 获取学生姓名的新列表
List<String> names = students.stream().map(Student::getName).collect(Collectors.toList());
List<Integer> ages = students.stream().mapToInt(Student::getAge).boxed().collect(Collectors.toList());
System.out.println(names);
System.out.println(ages);

结果：

[小张, 小李, 小王, 小红, 李华, 小潘, 小聂]
[16, 16, 17, 18, 15, 19, 20]



合并元素

语法：

<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner)
identity：合并标识值（因子），它将参与累加函数和合并函数的运算（即提供一个默认值，在流为空时返回该值，当流不为空时，该值作为起始值，参与每一次累加或合并计算）
accumulator：累加函数（将流元素和identity进行累加，流元素可以不与identity相同，但是在累加函数中，需要确保返回的值类型与identity相同）
combiner：合并函数（合并多个标识值，与collect方法的combiner参数原理类似，都是用于多线程时的合并策略）

// identity和accumulator操作原理大致如下
// 而合并函数的作用是将多个result相加（多线操作时的合并），相当于多个线程同时执行下面的方法，最后将这些方法执行的结构合并
U result = identity;
for (T element : this stream)
    result = accumulator.apply(result, element)
return result;

用例：

// 合并所有姓名
String reduce = students.stream().reduce(new StringBuffer(), (result, student) -> result.append(student.getName()), (r1, r2) -> r1.append(r2.toString())).toString();
// 简单写法，通过map和reduce操作的显式组合，能更简单的表示
Optional<String> reduce1 = students.stream().map(Student::getName).reduce(String::concat);
// 当然如果只是简单的字符串拼接，完全可以直接使用Collectors.joining的连接函数来实现
String reduce2 = students.stream().map(Student::getName).collect(Collectors.joining(","))
System.out.println(reduce);

结果：

小张小李小王小红李华小潘小聂

关于identity的示例：

// 这里标识值为0，累加器将会从如下等式开始累加计算：0 + student.getScore() 
Integer reduce2 = students.stream().reduce(0, (integer, student) -> integer + student.getScore(), Integer::sum);
// 这里标识值为10，累加器将会从如下等式开始累加计算：10 + student.getScore() 
Integer reduce3 = students.stream().reduce(10, (integer, student) -> integer + student.getScore(), Integer::sum);
System.out.println(reduce2);
System.out.println(reduce3);

结果：

442
452



过滤筛选

语法：

Stream filter(Predicate<? super T> predicate)

用例：

// 只获取高一的数学成绩
List<Student> math = students.stream()
        .filter(student -> student.getClazz().contains("高一") && "数学".equals(student.getCourse()))
        .collect(Collectors.toList());
System.out.println(math);

结果：

[Student(name=小李, age=16, clazz=高一3班, score=12, course=数学)]



截断（物理分页）

语法：

Stream skip(long n)

Stream limit(long maxSize)

用例：

// 取第二页，每页五条数据
List<Student> page = students.stream().skip(5).limit(5).collect(Collectors.toList());
System.out.println(page);

结果：

[Student(name=小潘, age=19, clazz=高三4班, score=100, course=英语), Student(name=小聂, age=20, clazz=高三4班, score=32, course=物理)]



排序

语法：

Stream sorted()
按照自然规则排序

Stream sorted(Comparator<? super T> comparator)
根据比较器进行排序，可以通过实现Comparator#compare方法，来创建自定义的比较器

用例：

// 按成绩排序，成绩相同时根据年龄排倒序
List<Student> sorted = students.stream()
        .sorted(Comparator.comparing(Student::getScore, Comparator.reverseOrder()).thenComparing(Student::getAge, Comparator.reverseOrder()))
        .collect(Collectors.toList());
// 普通写法
List<Student> sorted2 = students.stream()
        .sorted((c1, c2) -> {
            if (c1.getScore() > c2.getScore()) {
                return -1;
            } else if (c1.getScore().equals(c2.getScore())) {
                if (c1.getAge()>c2.getAge()) {
                    return -1;
                } else if (c1.getAge() < c2.getAge()){
                    return 1;
                }
                return 0;
            }
            return 1;
        })
        .collect(Collectors.toList());
System.out.println(sorted);
System.out.println(sorted2);

结果：

[Student(name=小潘, age=19, clazz=高三4班, score=100, course=英语), Student(name=李华, age=15, clazz=高二2班, score=99, course=数学), Student(name=小张, age=16, clazz=高一1班, score=88, course=历史), Student(name=小红, age=18, clazz=高二1班, score=67, course=物理), Student(name=小王, age=17, clazz=高二1班, score=44, course=地理), Student(name=小聂, age=20, clazz=高三4班, score=32, course=物理), Student(name=小李, age=16, clazz=高一3班, score=12, course=数学)]
[Student(name=小潘, age=19, clazz=高三4班, score=100, course=英语), Student(name=李华, age=15, clazz=高二2班, score=99, course=数学), Student(name=小张, age=16, clazz=高一1班, score=88, course=历史), Student(name=小红, age=18, clazz=高二1班, score=67, course=物理), Student(name=小王, age=17, clazz=高二1班, score=44, course=地理), Student(name=小聂, age=20, clazz=高三4班, score=32, course=物理), Student(name=小李, age=16, clazz=高一3班, score=12, course=数学)]



最大值最小值

语法：

Optional max(Comparator<? super T> comparator)

Optional min(Comparator<? super T> comparator)

用例：

// 分数的最大值 最小值
Student max = students.stream().max(Comparator.comparing(Student::getScore)).orElse(null);
Student min = students.stream().min(Comparator.comparing(Student::getScore)).orElse(null);
// 也可以通过如下写法获取最大值，这种写法只能获取到值，没法关联用户，跟上面的写法各有用途
int max2 = students.stream().mapToInt(Student::getScore).max().orElse(0);
int min2 = students.stream().mapToInt(Student::getScore).min().orElse(0);
System.out.println(max);
System.out.println(min);

结果：

Student(name=小潘, age=19, clazz=高三4班, score=100, course=英语)
Student(name=小李, age=16, clazz=高一3班, score=12, course=数学)



计数求和、平均值

语法：

long count()

Optional reduce(BinaryOperator accumulator)
通过元素累加实现求和

用例：

// 计数求及格的学生人数
long count = students.stream().filter(student -> student.getScore() > 60).count();
// 求分数总和
Integer sum = students.stream().map(Student::getScore).reduce(Integer::sum).orElse(-1);
Integer sum2 = students.stream().mapToInt(Student::getScore).sum();
// 分数的平均值
double average = students.stream().mapToDouble(Student::getScore).average().orElse(0D);
System.out.println(count + "-" + sum + "-" + average);

结果：

4-442-63.142857142857146



分组

语法：

Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)

  • classifier：提供一个方法，该方法的返回值是键值对的键
  • mapFactory：提供一个容器初始化方法，用于创建新的Map容器（使用该容器存放值对），与之前的方法类型，这里同样可以使用并发加快流的处理速度。
  • downstream：同一分组的合并方法，将同一个类型合并为指定类型，该方法返回的是键值对的值

更多分组示例查看：Stream Collectors.groupingBy的四种用法 解决分组统计（计数、求和、平均数等）、范围统计、分组合并、分组结果自定义映射等问题

用例：

// 将不同课程的学生进行分类
HashMap<String, List<Student>> groupByCourse = (HashMap<String, List<Student>>)students.stream()
        .collect(Collectors.groupingBy(Student::getCourse));
// 上面的方法中，最终返回默认是HashMap，键值对中的值默认是ArrayList，可以通过下面的方法自定义返回结果、值的类型
HashMap<String, List<Student>> groupByCourse1 = students.stream()
        .collect(Collectors.groupingBy(Student::getCourse, HashMap::new, Collectors.toList()));
// 增加映射功能，将值设置为名字
HashMap<String, List<String>> groupMapping = students.stream()
        .collect(Collectors.groupingBy(Student::getCourse, HashMap::new, Collectors.mapping(Student::getName, Collectors.toList())));
// 增加合并函数，计算每科总分
HashMap<String, Integer> groupCalcSum = students.stream()
        .collect(Collectors.groupingBy(Student::getCourse, HashMap::new, Collectors.reducing(0, Student::getScore, Integer::sum)));
// 增加平均值计算
HashMap<String, Double> groupCalcAverage = students.stream()
        .collect(Collectors.groupingBy(Student::getCourse, HashMap::new, Collectors.averagingDouble(Student::getScore)));
System.out.println(groupByCourse);
System.out.println(groupMapping);
System.out.println(groupCalcSum);
System.out.println(groupCalcAverage);

结果：

{物理=[Student(name=小红, age=18, clazz=高二1班, score=67, course=物理), Student(name=小聂, age=20, clazz=高三4班, score=32, course=物理)], 历史=[Student(name=小张, age=16, clazz=高一1班, score=88, course=历史)], 数学=[Student(name=小李, age=16, clazz=高一3班, score=12, course=数学), Student(name=李华, age=15, clazz=高二2班, score=99, course=数学)], 英语=[Student(name=小潘, age=19, clazz=高三4班, score=100, course=英语)], 地理=[Student(name=小王, age=17, clazz=高二1班, score=44, course=地理)]}

{物理=[小红, 小聂], 历史=[小张], 数学=[小李, 李华], 英语=[小潘], 地理=[小王]}

{物理=99, 历史=88, 数学=111, 英语=100, 地理=44}

{物理=49.5, 历史=88.0, 数学=55.5, 英语=100.0, 地理=44.0}



去重

语法：

Stream distinct()

用例：

// 去重 统计所有科目
List<String> courses = students.stream().map(Student::getCourse).distinct().collect(Collectors.toList());
System.out.println(courses);

结果：

[历史, 数学, 地理, 物理, 英语]



如果本文对你有帮助，请不要吝啬你的点赞，求赞求收藏♥♥♥

涝山道士
关注
专栏目录
K.Java8StreamAPI中文文档翻译版
AI天才研究院
07-29 1161
Java 8引入了Stream流处理框架，它可以让程序员用声明式的方式处理数据集合。Stream提供了高效且易于使用的API用来对数据进行过滤、排序、映射等操作。它通过极少的代码来实现复杂的数据处理任务，而且使用起来很方便。本文档将教你如何使用Java 8中的Stream API处理数据，包括创建流对象、中间操作、终止操作、并行执行和调试。本文档适用于有一定编程经验，对数据处理有需求但不熟悉Stream API的初级用户。阅读本文档后，你可以掌握Stream API的基础知识并能够使用它有效地处理数据。
Java 8 Stream API 性能优化技巧
AI天才研究院
07-30 1156
Java 8引入了Stream API，它是一个用来处理集合数据流的API。在日常开发中，Stream API可以有效提高编程效率，改善代码可读性、代码质量和程序运行效率等。但是Stream API的高级特性也使得其在性能方面也存在不少问题需要解决。本文将结合实际案例，通过对Stream API的工作原理和具体优化方法，给出一些经验心得，帮助读者有效提升Java程序中的Stream API性能。本文既适用于有一定编程经验的程序员阅读，也适合作为技术博客或培训讲座分享。
java8 stream 过滤、排序、求和、分组、去重等方法使用和说明
qq_44293888的博客
08-10 1万+
定义一个实体 import lombok.Data; @Data public class TestVO { /** * 主键 */ private long id; /** * 姓名 */ private String name; /** * 年龄 */ private String age; }
java8 stream自定义分组求和并排序的实现
08-25
主要介绍了java8 stream自定义分组求和并排序的实现,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java Stream流中的filter()使用方法-详解
最新发布
weixin_45638884的博客
10-10 2088
filter()是一个中间操作，用于根据给定的Predicate对流中的元素进行筛选，保留符合条件的元素。它不会改变元素的类型，只会决定哪些元素可以继续传递到下一个流操作。由于filter()是惰性求值的，中间操作只有在终端操作被调用时才会执行。filter()适合用于各种复杂对象的筛选，并且可以与map()等其他流操作结合使用。
Java8 stream排序
qq_36894763的博客
09-22 1万+
java8的Stream排序语法
java8 stream流排序
qq_53825610的博客
08-18 926
Stream流是一个序列化的对象集合，在Java中用于处理大量数据的一种工具。Stream可以对集合进行筛选、排序、聚合等操作，并且这些操作可以链式进行，最后可以将结果返回成一个新的Stream或者其他数据类型。Stream能够将数据集合中的元素进行并行处理，因此能够有效提高程序的执行效率。在Java 8中，引入了Stream API，使得Stream在程序设计中使用更加便捷。方法用来收集排序后的结果并将其转换为一个新的列表。
Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】
Tony666688888的博客
04-07 7412
java8 Stream中sorted排序
【java8】Stream流对多个字段进行排序
morris
04-30 1万+
在Java8中，你可以使用Stream接口的sorted()方法来对集合中的元素进行排序。这个方法接受一个Comparator对象作为参数，用于定义排序规则。如果你需要根据多个字段进行排序，你可以链式地调用thenComparing()或thenComparingInt()、thenComparingLong()、thenComparingDouble()等方法。
java8 Stream API
xc_oo0的博客
01-29 1026
java stream Java 8 java.util.stream Stream API的中间操作有filter、map、distinct、sorted、skip、limit、peek、mapToLong、mapToInt、mapToDouble、flatMap等 Stream API的终端操作有collect、max、min、count、allMatch、anyMatch、noneMatch、findFirst、findAny、forEach、toArray、reduce等。
Java Stream流介绍和使用说明
weixin_42704604的博客
07-01 348
Stream作为java8中增加的一个非常重要特性，为我们提供了对集合的一系列操作，简化了对集合元素的操作复杂度，让我们可以更加专注与业务逻辑的实现，stream的操作一般需要和Lambda表达式进行结合使用，达到简便的操作及清晰的代码。Stream流不是数据结构，不会改变源数据，而是通过对源数据的操作来产生新的数据流。Stream流支持链式操作，可以进行多个操作的组合，使得代码更加简洁。Stream流支持延迟操作，只有在终止操作时才会进行计算，可以提高程序的性能。
JAVA 8 Stream 集合的基本
coderWang
08-29 460
一、什么是Stream流 Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。 Stream有三大特性： 1.stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。 2.stream不会改变数据源，通常情况下会产生一个新的集合或一个值。 3.stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。 Stream可以由数组或集合创建，对流的操作分为两种： 1.中间操作，每次返回一个新的流，可以
【JAVA】jdk8 Stream 排序精通
weixin_41979605的博客
02-14 5645
因为对象比基本类型占用空间大，如果排完序之后再翻转，而同时数组长度比较大，那么就可能有性能问题，所以可以直接指定排序的方向，避免不必要的浪费。但是对于完全的数值比较，其实就按照默认的比较即可，给Stream 排序的值即可,特别是对象，只需要指定字段即可。jdk8的stream流能方便的排序，但是每次都要查资料，非常不方便，不确定，所以这次直接弄懂，不再迷茫。,字符串比较很简单，就是字符依次比较，从小到大，第一位相同比第二位，依次排序。因此对象排序，优先使用这样的方式去指定排序，特别是倒序的时候。
Java8的stream之groupingBy()分组排序
李长渊的博客
09-20 1万+
Java8的stream之groupingBy()分组排序
java8的Stream的排序
热门推荐
ziwenCSDN的博客
11-24 4万+
java8 Stream的各种排序
java8 stream流求和计算
qq_38349413的博客
04-27 1万+
通过for或者foreach循环的方式逐个累加某个字段的和太过繁琐，本文通过stream流的方式展示一行代码求字段和。直接上代码 /** * @author Mikey * @version 1.0 * @date 2022/4/27 15:13 * @description */ public class CalculateDemo { public static void main(String[] args) { List<BigDecimal> test
Java8 Stream排序
08-06 9561
/* * 排序 * sorted():自然排序(Comparable) * sorted(Comparator com)：定制排序(Comparator) */ List list3 = Arrays.asList("aa", "bb", "cc", "dd", "ee"); list3.stream() .sorted() .forEach(System.
java8 使用stream进行排序(多字段排序、升序、降序)
一点点
11-18 6180
java8 使用stream进行排序(多字段排序、升序、降序)
通过stream去重_java 8 stream、lambda表达式对list操作分组、过滤、求和、最值、排序、去重...
05-20
Java 8 的 stream 和 lambda 表达式提供了非常方便的操作 list 的方式，下面是通过 stream 去重的示例代码： ```java List<Integer> list = Arrays.asList(1, 2, 3, 2, 4, 1); List<Integer> distinctList = list.stream().distinct().collect(Collectors.toList()); System.out.println(distinctList); // 输出 [1, 2, 3, 4] ``` 上述代码中，我们首先创建了一个包含重复元素的 list，然后通过 stream() 方法将其转换为 Stream 对象，接着调用 distinct() 方法去重，最后用 collect(Collectors.toList()) 方法将 Stream 转换为 List。 除了去重，stream 还提供了很多其他的操作，如分组、过滤、求和、最值、排序等等。下面是一些示例代码： ```java // 分组 Map<Boolean, List<Integer>> groupByEven = list.stream().collect(Collectors.partitioningBy(i -> i % 2 == 0)); System.out.println(groupByEven); // 输出 {false=[1, 3, 1], true=[2, 2, 4]} // 过滤 List<Integer> filteredList = list.stream().filter(i -> i > 2).collect(Collectors.toList()); System.out.println(filteredList); // 输出 [3, 4] // 求和 int sum = list.stream().mapToInt(Integer::intValue).sum(); System.out.println(sum); // 输出 13 // 最值 Optional<Integer> max = list.stream().max(Integer::compare); System.out.println(max.get()); // 输出 4 // 排序 List<Integer> sortedList = list.stream().sorted().collect(Collectors.toList()); System.out.println(sortedList); // 输出 [1, 1, 2, 2, 3, 4] // 去重 List<Integer> distinctList2 = list.stream().distinct().collect(Collectors.toList()); System.out.println(distinctList2); // 输出 [1, 2, 3, 4] ``` 上述代码中，我们使用 partitioningBy() 方法将 list 分成奇数和偶数两组；使用 filter() 方法过滤出大于 2 的元素；使用 mapToInt() 方法将 Integer 转换为 int，再使用 sum() 方法求和；使用 max() 方法找出最大值；使用 sorted() 方法排序；使用 distinct() 方法去重。注意，使用 distinct() 方法去重时，需要保证元素的类型实现了 equals() 和 hashCode() 方法，否则可能会出现意外的结果。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值