Java8 stream()特性使用总结

于 2022-12-30 16:16:08 发布
阅读量933 收藏 3
点赞数
分类专栏： jdk 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36090537/article/details/128492223
版权

stream()可以对数组/集合操作，提供排序、去重、分组、过滤等多种操作。

目录

1.升序，降序sort使用：

2.取年龄最大值max，最小值min，规约reduce用法：

3.取总分数summary，平均分average用法(两种方法)：

4.连接字符串joining使用：

6.分组/条件分组/多级分组/分组统计groupingBy使用：

7.遍历foreach/匹配match/find

8.筛选filter/转list

9.map/转map使用

10.提取/合并concat/跳过skip

11.取两个集合的差集，交集

先初始化list，以对象集合为例：

static List<Student> students = new ArrayList<>();
    static {
        students.add(new Student(1,"学生A", 20, 2, 98.0));
        students.add(new Student(2,"学生B", 19, 1, 91.0));
        students.add(new Student(3,"学生C", 23, 1, 90.0));
        students.add(new Student(4,"学生D", 20, 2, 76.0));
        students.add(new Student(5,"学生E", 21, 2, 91.0));
        students.add(new Student(6,"学生F", 18, 1, 65.0));
        students.add(new Student(7,"学生G", 20, 2, 80.0));
        students.add(new Student(8,"学生H", 19, 2, 78.0));
        students.add(new Student(9,"学生I", 18, 1, 67.0));
        students.add(new Student(10,"学生J", 17, 1, 87.0));
    }

1.升序，降序sort使用：

        // 按年龄升序排序（自然排序）
        List<String> newList = students.stream().sorted(Comparator.comparing(Student::getAge)).map(Student::getName).collect(Collectors.toList());
        // 按年龄倒序排序
        List<String> newList2 = students.stream().sorted(Comparator.comparing(Student::getAge).reversed()).map(Student::getName).collect(Collectors.toList());
        // 先按年龄再按分数升序排序
        List<String> newList3 = students.stream().sorted(Comparator.comparing(Student::getAge).thenComparing(Student::getScore)).map(Student::getName).collect(Collectors.toList());
        // 先按年龄再按分数自定义排序（降序）
        List<String> newList4 = students.stream().sorted((p1, p2) -> {
            if (p1.getAge() == p2.getAge()) {
                return (int) (p2.getScore() - p1.getScore());
            } else {
                return p2.getAge() - p1.getAge();
            }
        }).map(Student::getName).collect(Collectors.toList());

        System.out.println("按年龄升序排序：" + newList);
        System.out.println("--------------------------");
        System.out.println("按年龄倒序排序：" + newList2);
        System.out.println("--------------------------");
        System.out.println("先按年龄再按分数升序排序：" + newList3);
        System.out.println("--------------------------");
        System.out.println("先按年龄再按分数自定义排序：" + newList4);
        /**
         * 按工资升序排序：[学生J, 学生F, 学生I, 学生B, 学生H, 学生A, 学生D, 学生G, 学生E, 学生C]
         * --------------------------
         * 按工资降序排序：[学生C, 学生E, 学生A, 学生D, 学生G, 学生B, 学生H, 学生F, 学生I, 学生J]
         * --------------------------
         * 先按工资再按年龄升序排序：[学生J, 学生F, 学生I, 学生H, 学生B, 学生D, 学生G, 学生A, 学生E, 学生C]
         * --------------------------
         * 先按工资再按年龄自定义降序排序：[学生C, 学生E, 学生A, 学生G, 学生D, 学生B, 学生H, 学生I, 学生F, 学生J]
         */

2.取年龄最大值max，最小值min，规约reduce用法：

        Optional<Student> collect1 = students.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge()));
        Optional<Student> collect2 = students.stream().collect(Collectors.minBy((s1, s2) -> s1.getAge() - s2.getAge()));
        System.out.println("max年龄的学生==>" + collect1.get());
        System.out.println("min年龄的学生==>" + collect2.get());
        /**
         * max年龄的学生==>Student(name=学生C, age=23, sex=1, score=90.0)
         * min年龄的学生==>Student(name=学生J, age=17, sex=1, score=87.0)
         */
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        //求和
        Optional<Integer> reduce = list.stream().reduce((x,y) -> x+ y);
        System.out.println("求和:"+reduce);
        //求积
        Optional<Integer> reduce2 = list.stream().reduce((x,y) -> x * y);
        System.out.println("求积:"+reduce2);
        //求最大值
        Optional<Integer> reduce3 = list.stream().reduce((x,y) -> x>y?x:y);
        System.out.println("求最大值:"+reduce3);
        /**
         * 求和:Optional[10]
         * 求积:Optional[24]
         * 求最大值:Optional[4]
         */

3.取总分数summary，平均分average用法(两种方法)：

        //方法一
        Double summingScore = students.stream().collect(Collectors.summingDouble(Student::getScore));
        Double averagingScore = students.stream().collect(Collectors.averagingDouble(Student::getScore));
        System.out.println("学生的总分==>" + summingScore);
        System.out.println("学生的平均分==>" + averagingScore);
        /**
         * 学生的总分==>823.0
         * 学生的平均分==>82.3
         */

        //方法二
        DoubleSummaryStatistics summarizingDouble = students.stream().collect(Collectors.summarizingDouble(Student::getScore));
        System.out.println("sum==>"+summarizingDouble.getSum());
        System.out.println("count==>"+summarizingDouble.getCount());
        System.out.println("average==>"+summarizingDouble.getAverage());
        System.out.println("max==>"+summarizingDouble.getMax());
        System.out.println("min==>"+summarizingDouble.getMin());
        /**
         * sum==>823.0
         * count==>10
         * average==>82.3
         * max==>98.0
         * min==>65.0
         */

4.连接字符串joining使用：

        String studentsName = students.stream().map(student -> student.getName()).collect(Collectors.joining());
        System.out.println(studentsName);
        String studentsName2 = students.stream().map(student -> student.getName()).collect(Collectors.joining(","));
        System.out.println(studentsName2);
        /**
         * 学生A学生B学生C学生D学生E学生F学生G学生H学生I学生J
         * 学生A,学生B,学生C,学生D,学生E,学生F,学生G,学生H,学生I,学生J
         */

6.分组/条件分组/多级分组/分组统计groupingBy使用：

        //根据性别字段分组
        Map<Integer, List<Student>> sexMap = students.stream().collect(Collectors.groupingBy(daliy -> daliy.getSex()));
        System.out.println(sexMap);
        /**
         * {1=[Student(id=2, name=学生B, age=19, sex=1, score=91.0), Student(id=3, name=学生C, age=23, sex=1, score=90.0), 
         * Student(id=6, name=学生F, age=18, sex=1, score=65.0), Student(id=9, name=学生I, age=18, sex=1, score=67.0), 
         * Student(id=10, name=学生J, age=17, sex=1, score=87.0)], 
         * 2=[Student(id=1, name=学生A, age=20, sex=2, score=98.0), Student(id=4, name=学生D, age=20, sex=2, score=76.0), 
         * Student(id=5, name=学生E, age=21, sex=2, score=91.0), Student(id=7, name=学生G, age=20, sex=2, score=80.0), 
         * Student(id=8, name=学生H, age=19, sex=2, score=78.0)]}
         */

        //加条件分组
        Map<String, List<Student>> collect = students.stream().collect(Collectors.groupingBy(student -> {
            if (student.getAge() > 20) {
                return "20岁以上的";
            }
            return "20以下的";
        }));
        System.out.println(collect);
        /**
         * {20以下的=[Student(id=1, name=学生A, age=20, sex=2, score=98.0), Student(id=2, name=学生B, age=19, sex=1, score=91.0), 
         * Student(id=4, name=学生D, age=20, sex=2, score=76.0), Student(id=6, name=学生F, age=18, sex=1, score=65.0), 
         * Student(id=7, name=学生G, age=20, sex=2, score=80.0), Student(id=8, name=学生H, age=19, sex=2, score=78.0), 
         * Student(id=9, name=学生I, age=18, sex=1, score=67.0), Student(id=10, name=学生J, age=17, sex=1, score=87.0)], 
         * 20岁以上的=[Student(id=3, name=学生C, age=23, sex=1, score=90.0), Student(id=5, name=学生E, age=21, sex=2, score=91.0)]}
         */

        //统计20岁年龄以上和20以下的学生男/女分别有多少
        Map<Integer, Map<String, List<Student>>> collect = students.stream().collect(Collectors.groupingBy(Student::getSex, Collectors.groupingBy(student -> {
            if (student.getAge() > 20) {
                return "20以上的";
            }
            return "20岁以下的";
        })));
        System.out.println(collect);
        /**
         * {1={20以上的=[Student(id=3, name=学生C, age=23, sex=1, score=90.0)], 
         * 20岁以下的=[Student(id=2, name=学生B, age=19, sex=1, score=91.0), Student(id=6, name=学生F, age=18, sex=1, score=65.0), Student(id=9, name=学生I, age=18, sex=1, score=67.0), Student(id=10, name=学生J, age=17, sex=1, score=87.0)]}, 
         * 2={20以上的=[Student(id=5, name=学生E, age=21, sex=2, score=91.0)], 
         * 20岁以下的=[Student(id=1, name=学生A, age=20, sex=2, score=98.0), Student(id=4, name=学生D, age=20, sex=2, score=76.0), Student(id=7, name=学生G, age=20, sex=2, score=80.0), Student(id=8, name=学生H, age=19, sex=2, score=78.0)]}}
         */

        //按照性别分组统计人数
        Map<Integer, Long> collect = students.stream().collect(Collectors.groupingBy(Student::getSex, Collectors.counting()));
        System.out.println(collect);
        /**
         * {1=5, 2=5}
         */

7.遍历foreach/匹配match/find

        // 遍历输出符合条件的元素
        students.stream().filter(x -> x.getAge() > 22).forEach(System.out::println);
        // 匹配第一个
        Optional<Student> findFirst = students.stream().filter(x -> x.getScore() > 90).findFirst();
        // 匹配任意（适用于并行流）
        Optional<Student> findAny = students.parallelStream().filter(x -> x.getName().contains("A")).findAny();
        //Optional<Student> findAny = students.parallelStream().filter(x -> x.getAge()>20).findAny();
        // 是否包含符合特定条件的元素
        boolean anyMatch = students.stream().anyMatch(x -> x.getAge() < 22);
        System.out.println("匹配第一个值：" + findFirst.get());
        System.out.println("匹配任意一个值：" + findAny.get());
        System.out.println("是否存在大于22的值：" + anyMatch);
        /**
         * Student(id=3, name=学生C, age=23, sex=1, score=90.0)
         * 匹配第一个值：Student(id=1, name=学生A, age=20, sex=2, score=98.0)
         * 匹配任意一个值：Student(id=1, name=学生A, age=20, sex=2, score=98.0)
         * 是否存在大于22的值：true
         */

8.筛选filter/转list

        //筛选年龄大于20的人
        students.stream().filter(x -> x.getAge()>20).collect(Collectors.toList()).forEach(System.out::println);
        /**
         * Student(id=3, name=学生C, age=23, sex=1, score=90.0)
         * Student(id=5, name=学生E, age=21, sex=2, score=91.0)
         */

        //取学生ID集合
        List<Integer> ids = students.stream().map(Student::getId).collect(Collectors.toList());
        System.out.println(ids);
        /**
         * [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
         */

9.map/转map使用

        //转大小写
        List<String> stringList = Arrays.asList("dsdD", "erg", "HGY", "dfg");
        List<String> upperCollect = stringList.stream().map(x -> x.toUpperCase(Locale.ROOT)).collect(Collectors.toList());
        List<String> lowerCollect = stringList.stream().map(x -> x.toLowerCase(Locale.ROOT)).collect(Collectors.toList());
        System.out.println(upperCollect);
        System.out.println(lowerCollect);
        /**
         * [DSDD, ERG, HGY, DFG]
         * [dsdd, erg, hgy, dfg]
         */
        //集合元素+3
        List<Integer> list = Arrays.asList(1, 17, 27, 7);
        List<Integer> collect = list.stream().map(x -> x + 3).collect(Collectors.toList());
        System.out.println(collect);
        /**
         * [4, 20, 30, 10]
         */
        //分数+5
        List<Student> collect1 = students.stream().map(x -> {
            x.setScore(x.getScore()+5);
            return x;
        }).collect(Collectors.toList());
        collect1.forEach(p -> System.out.println(p.getScore()));
        /**
         *103.0
         * 96.0
         * 95.0...
         */

        //按照ID转为map
        Map<Integer, Student> checkMap1 = students.stream().collect(Collectors.toMap(Student::getId, Function.identity()));
        System.out.println(checkMap1);
        //取出年龄>18的用户转为map
        Map<String, Student> checkMap2 = students.stream().filter(x -> x.getAge() > 18).collect(Collectors.toMap(Student::getName, y -> y));
        System.out.println(checkMap2);
        /**
         * {1=Student(id=1, name=学生A, age=20, sex=2, score=98.0), 2=Student(id=2, name=学生B, age=19, sex=1, score=91.0)...}
         * {学生E=Student(id=5, name=学生E, age=21, sex=2, score=91.0), 学生H=Student(id=8, name=学生H, age=19, sex=2, score=78.0)...}
         */

10.提取/合并concat/跳过skip

        String[] arr1 = { "a", "b", "c", "d" };
        String[] arr2 = { "d", "e", "f", "g" };
        Stream<String> stream1 = Stream.of(arr1);
        Stream<String> stream2 = Stream.of(arr2);
        // concat:合并两个流 distinct：去重
        List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
        // limit：限制从流中获得前n个数据
        List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
        // skip：跳过前n个数据
        List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
        System.out.println("流合并：" + newList);
        System.out.println("limit：" + collect);
        System.out.println("skip：" + collect2);
        /**
         * 流合并：[a, b, c, d, e, f, g]
         * limit：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
         * skip：[3, 5, 7, 9, 11]
         */

11.取两个集合的差集，交集

        //取差集 即 数据集中不包含数据源中的数据
        List<String> stringList1 = Arrays.asList("abc", "efd", "tgh", "uji");
        List<String> stringList2 = Arrays.asList("sf", "vgf", "abc", "tgh");
        List<String> reduce1 = stringList1.stream().filter(item -> !stringList2.contains(item)).collect(Collectors.toList());
        System.out.println(reduce1);
        //取交集
        List<String> reduce2 = stringList1.stream().filter(item -> stringList2.stream().collect(Collectors.toList()).contains(item)).collect(Collectors.toList());
        System.out.println(reduce2);
        /**
         * [efd, uji]
         * [abc, tgh]
         */

就总结到这了，方法可以根据需要自取。

qianQueen
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8 新特性之Stream（四）-- Stream的summaryStatistics()
PUYALEI的博客
10-15 293
Java8 新特性之Stream（四）-- Stream的summaryStatistics()
Java Stream API 之 findFirst()
最新发布
HY
05-22 220
Java Stream API 之 findFirst()
Java8 Stream总结
qq_37634156的博客
12-07 230
1 Stream概述 Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的Lambda，给我们操作集合（Collection）提供了极大的便利。 那么什么是Stream？ Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。 Stream可以由数组或集合创建，对流的操作分为两种： 1、中间操作，每次返回一个新的流，可以有多个。 2、终端操作，每个流只...
java8 stream_使用Java Stream摘要统计
cunfeng7797的博客
01-01 186
java8 stream 基本类型的流( IntStream等)提供了summaryStatistics( )方法，该方法可用于获取流的多个统计属性(最小值，平均值等)。 假设我们有一个人的名单。 我们的目标是使用信息流获取列表中人员的最小和最大年龄。 这里的问题是最小值和最大值的计算是终端流操作。 因此，我们需要提出自己的归约实现或为每次计算创建一个新的流。 天真的实现可能看起来像这样： ...
Java8新特性 - Stream - 01 - Stream的概述
northcastle的博客
03-12 418
1.什么是Stream Stream 是Java中对集合操作的一种更为简便的封装。 使用Stream可以让代码更为简洁。 2.Stream的使用注意点 3.Stream的初体验 4.完成 Congratulations！ You are one step closer to success!
Stream之判断(anyMatch allMatch noneMatch)
一起coding，一起嗨。
05-01 2916
一 方法介绍 anyMatch：判断的条件里，任意一个元素成功，返回true allMatch：判断条件里的元素，所有的都是，返回true noneMatch：与allMatch相反，判断条件里的元素，所有的都不是，返回true 二 示例 @Data @AllArgsConstructor @NoArgsConstructor @EqualsAndHashCode public class Person { private String name; private Intege
java8 stream使用总结
08-16
以下是对"Java 8 Stream使用总结"的详细说明： 1. **什么是Stream**： Stream API是一个在Java 8中引入的概念，它提供了一种全新的处理数据的方式，可以看作是从集合到计算的一种桥梁。Stream不是存储数据的数据...
Java8特性Stream流的使用（学完就会，项目源码，附带个人总结）
09-09
Java8是Java语言的一个重要版本，引入了许多新特性，其中最为引人注目的就是Stream API。Stream API极大地改进了集合操作的方式，使得处理大量数据变得更加高效、简洁和易读。以下将详细介绍Stream流的使用，以及它...
java8新特性之stream的collect实战教程
08-18
Java8新特性之Stream的Collect实战教程 Java8中引入了Stream API，它是一个功能强大且灵活的数据处理工具。Stream API提供了一个高效的方式来处理数据，特别是在处理大量数据时。Stream API的核心是collect方法，它...
java8新特性总结
10-08
详细java8特性讲解，lambda语法与使用，函数式接口注意点，stream API以及执行流程等特性解说
JDK8新特性(九)之Stream流的find()、max()、min()、reduce()方法
北辰
12-19 2161
1.Stream流的find()方法 如果需要找到某些数据，可以使用find相关方法。方法声明： Optional<T> findFirst(); Optional<T> findAny(); import java.util.Optional; import java.util.stream.Stream; public class Demo { public static void main(String[] args) { Stream
Java8 Stream 流 使用方式
weixin_47460834的博客
08-05 295
流，是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算。(1)对于开发人员来说，使用处理流进行输入、输出操作更简单；(2)使用处理流执行效率更高。.........
Java 8 Stream的用法详解
京北游戏官方
09-22 1万+
一、概述 Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。 特点 1、不是数据结构，不会保存数据 2、不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。 3、惰性求职，流在中间处理过程中，只是对操作进行了记录，并不会立即
Java 8 Stream filter() + findFirst Example Tutorial +peek()方法案例
myvictoryhhb的专栏
09-17 3100
正如你所看到的，我们可以使用 Predicate 来指定条件，它只是一个函数式接口，只有一个方法 test()，它返回一个布尔值。顾名思义，findFirst 方法返回 Stream 中的第一个元素，包装在 Optional 中，但前提是 Stream 保持顺序，例如从 ArrayList 或 LinkedHashMap 生成的 Stream 保持元素有序。由于 filter() 是惰性的，它只会处理满足 findFirst() 标准所需的元素，这就是为什么不需要处理所有元素的原因。它没有触及11和13。
stream().filter()的用法
热门推荐
点点滴滴
09-08 13万+
stream.filter一般适用于list集合,主要作用就是模拟sql查询，从集合中查询想要的数据。filter里面的参数user是指集合里面的每一项 public class StreamTest{ public static void main(String[] args){ List<User> list = new ArrayList<>(); //定义三个用户对象 User user1 = new User();
在java 8 stream表达式中实现if/else逻辑
程序那些事
04-22 1万+
文章目录简介传统写法使用filter总结 简介 在Stream处理中，我们通常会遇到if/else的判断情况，对于这样的问题我们怎么处理呢？ 还记得我们在上一篇文章lambda最佳实践中提到，lambda表达式应该越简洁越好，不要在其中写臃肿的业务逻辑。 接下来我们看一个具体的例子。 传统写法 假如我们有一个1 to 10的list，我们想要分别挑选出奇数和偶数出来，传统的写法，我们会这样使用： ...
Java学习笔记-stream().filter()
一片蓝蓝的云
12-21 4453
最近又看到别人用这种东西： stream().filter(timerTaskDTO -> ("N") .equals(timerTaskDTO.getIsActive())).collect(Collectors.toList());、 作用：查找符合条件的对象集合，所以返回值一定是个List 用法： //在集合中查询用户名为huxiansen的集合 List<User> userList = list.stream().filte...
优雅的找出ArrayList中重复的元素
不见其长，日有所长
08-29 2343
1. 使用java 8 的stream实现 import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Main { public static <E> List<E> getDuplicateElements(List&lt...
java1.8新特性stream流
09-12
Java 8引入了stream流作为一种新的特性。stream流是对集合进行处理的一种方式，它提供了一种函数式编程的方式来操作集合数据。使用stream流可以更简洁地处理集合操作，比如过滤、映射、排序等。stream流可以通过集合的stream()方法获取。在Map中，可以分别通过keySet()、values()、entrySet()来获取key流、value流和entry流。 另外，如果要将两个流合并成一个流，可以使用Stream类的concat方法。该方法接受两个流作为参数，并返回一个合并后的流。可以通过Stream.concat(streamA, streamB)来实现流的合并。 总结来说，Java 8新特性的stream流提供了一种方便、简洁的方式来处理集合数据，可以更高效地进行操作和处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值