Stream流技术的使用

Adda_Chen

已于 2024-08-12 15:46:57 修改

阅读量181

点赞数

分类专栏：学习笔记文章标签： java 开发语言 idea

于 2023-05-03 01:14:33 首次发布

本文链接：https://blog.csdn.net/adda_chen/article/details/130469114

版权

学习笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本文详细介绍了JavaStreamAPI的使用，包括从集合、数组、双列集合和零散数据生成流，使用filter、limit、skip、distinct等中间操作进行数据过滤和去重，以及使用forEach、count、toArray、collect等终结方法进行数据处理和收集。此外，还涵盖了排序、分组、转换为Map等各种场景下的StreamAPI应用。

摘要由CSDN通过智能技术生成

一.基础知识

二.使用步骤

1.生成流

①单列集合

        System.out.println("-------单列集合--------");
        //单列集合
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "a", "b", "c", "d");
        Stream<String> stream = list.stream();
        stream.forEach(System.out::println);

输出

-------单列集合--------
a
b
c
d

②双列集合

        System.out.println("-------双列集合--------");
        //双列集合
        HashMap<String, String> map = new HashMap<>();
        map.put("aaa", "111");
        map.put("bbb", "222");
        map.put("ccc", "222");
        //遍历键
        map.keySet().stream().forEach(System.out::println);
        //遍历元素
        map.entrySet().stream().forEach(System.out::println);

输出

-------双列集合--------
aaa
ccc
bbb
aaa=111
ccc=222
bbb=222

③数组

        System.out.println("-------数组--------");
        //数组
        int[] arr={1,2,3,4,5};
        Arrays.stream(arr).forEach(System.out::println);

输出

-------数组--------
1
2
3
4
5

④一堆零散数据

零散数据，必须得是同类型的

        System.out.println("-------零散数据--------");
        //一堆零散数据
        Stream.of(1,2,3,4,5).forEach(System.out::println);

输出

-------零散数据--------
1
2
3
4
5

2.使用api进行操作

①中间方法

代码举例，使用的集合数据如下

   /**
     * 创建简单的字符串集合
     *
     * @return
     */
    @Override
    public List<String> getSimpleStringList() {
        List<String> stringList=new ArrayList<>();
        stringList.add("张无忌");
        stringList.add("周芷若");
        stringList.add("赵敏");
        stringList.add("张强");
        stringList.add("张三丰");
        return stringList;
    }
    /**
     * 创建有重复数据的字符串集合
     *
     * @return
     */
    @Override
    public List<String> getRepeatStringList() {
        List<String> stringList=new ArrayList<>();
        stringList.add("张无忌");
        stringList.add("张无忌");
        stringList.add("赵敏");
        stringList.add("赵敏");
        stringList.add("张三丰");
        return stringList;
    }
    /**
     * 创建有名字+年龄 的字符串集合
     *
     * @return
     */
    @Override
    public List<String> getNameAgeStringList() {
        List<String> stringList=new ArrayList<>();
        stringList.add("张无忌-24");
        stringList.add("赵敏-20");
        stringList.add("张三丰-87");
        return stringList;
    }

filter - 过滤

    /**
     * filter - 过滤
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/filter")
    public void filter() {
        //获取测试集合数据
        List<String> stringList = createListService.getSimpleStringList();
        List<String> collect = stringList.stream()
                .filter(o -> o.startsWith("张"))
                .filter(o -> o.length() == 3)
                .collect(Collectors.toList());
        //打印原本的集合,stream流是创建新的集合，不会改变原本集合的数据
        System.out.println(stringList);
        //打印过滤后的集合
        System.out.println(collect);
    }

输出

[张无忌, 周芷若, 赵敏, 张强, 张三丰]
[张无忌, 张三丰]

limit - 获取前几个

    /**
     * limit - 获取前几个数据
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/limit")
    public void limit() {
        //获取测试集合数据
        List<String> stringList = createListService.getSimpleStringList();
        List<String> collect = stringList.stream()
                .limit(3)
                .collect(Collectors.toList());
        //打印原本的集合
        System.out.println(stringList);
        //打印集合的前三个数据
        System.out.println(collect);
    }

输出

[张无忌, 周芷若, 赵敏, 张强, 张三丰]
[张无忌, 周芷若, 赵敏]

skip - 跳过前几个

    /**
     * skip - 跳过前几个数据
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/skip")
    public void skip() {
        //获取测试集合数据
        List<String> stringList = createListService.getSimpleStringList();
        List<String> collect = stringList.stream()
                .skip(3)
                .collect(Collectors.toList());
        //打印集合中，除去前三个的数据
        System.out.println(stringList);
        //打印原本的集合
        System.out.println(collect);
    }

输出

[张无忌, 周芷若, 赵敏, 张强, 张三丰]
[张强, 张三丰]

distinct - 元素去重

    /**
     * distinct - 去重
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/distinct")
    public void distinct() {
        //获取测试集合数据
        List<String> stringList = createListService.getRepeatStringList();
        List<String> collect = stringList.stream()
                .distinct()
                .collect(Collectors.toList());
        //打印集合中，去重过后的数据
        System.out.println(stringList);
        //打印原本的集合
        System.out.println(collect);
    }

输出

[张无忌, 张无忌, 赵敏, 赵敏, 张三丰]
[张无忌, 赵敏, 张三丰]

concat - 合并两个流为一个

    /**
     * concat - 两个流合为一个
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/concat")
    public void concat() {
        //获取测试集合数据1
        List<String> repeatStringList = createListService.getRepeatStringList();
        List<String> simpleStringList = createListService.getSimpleStringList();
        //分别将两个集合转化为stream流
        Stream<String> repeatStream = repeatStringList.stream();
        Stream<String> simpleStream = simpleStringList.stream();
        //两个流合二为一
        Stream.concat(repeatStream,simpleStream).forEach(System.out::println);
    }

输出

张无忌
张无忌
赵敏
赵敏
张三丰
张无忌
周芷若
赵敏
张强
张三丰

map - 转换流中数据类型

    /**
     * map - 转换数据类型
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/map")
    public void map() {
        //获取测试集合数据1
        List<String> nameAgeStringList = createListService.getNameAgeStringList();
        List<Integer> collect = nameAgeStringList
                .stream()
                //转换数据类型
                .map(s -> {
                    //截取年龄，并转化为数字类型
                    String substring = s.substring(s.lastIndexOf("-")+1);
                    return Integer.valueOf(substring);
                })
                .collect(Collectors.toList());
        //原本的数据集合
        System.out.println(nameAgeStringList);
        //转换数据类型后的集合
        System.out.println(collect);
    }

输出

[张无忌-24, 赵敏-20, 张三丰-87]
[24, 20, 87]

②终结方法

forEach - 遍历

    /**
     * forEach - 遍历
     * forEach 属于终结方法，其后面不能在跟其余的方法了
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/forEach")
    public void forEach() {
        //获取集合数据
        List<String> simpleStringList = createListService.getSimpleStringList();
        //遍历操作，并打印
        simpleStringList.stream().forEach(s -> {
            s = s + " --";
            System.out.println(s);
        });
        //打印原来的数据
        System.out.println(simpleStringList);
    }

输出

张无忌 --
周芷若 --
赵敏 --
张强 --
张三丰 --
[张无忌, 周芷若, 赵敏, 张强, 张三丰]

count - 统计

    /**
     * count - 统计
     * count 属于终结方法，其后面不能在跟其余的方法了
     *  计算流中有多少个数据；
     * @return
     * @throws IOException
     */
    @GetMapping("/count")
    public void count() {
        List<String> simpleStringList = createListService.getSimpleStringList();
        long count = simpleStringList.stream().count();
        System.out.println("总共有：" + count + " 条数据");
        System.out.println(simpleStringList);
    }

输出

总共有：5 条数据
[张无忌, 周芷若, 赵敏, 张强, 张三丰]

toArray - 收集数据，放入数组 (重点)

    /**
     * toArray - 收集数据，放入数组 (重点)
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/toArray")
    public void toArray() {
        List<String> simpleStringList = createListService.getSimpleStringList();
        //这里toArray方法的lambda表达式形参size不再是每一个元素，而是元素的个数
        String[] strings = simpleStringList.stream().toArray(size -> new String[size]);
        //打印原来的数据集合
        System.out.println(simpleStringList);
        //打印数组
        System.out.println(Arrays.toString(strings));
    }

输出

[张无忌, 周芷若, 赵敏, 张强, 张三丰]
[张无忌, 周芷若, 赵敏, 张强, 张三丰]

collect - 收集数据，放入集合 (重点)

收集成list或者set

    /**
     * collect - 收集数据，放入集合  (重点)
     *  收集成集合或者set
     * @return
     * @throws IOException
     */
    @GetMapping("/collectToListSet")
    public void collectToList() {
        List<String> repeatStringList = createListService.getRepeatStringList();
        //打印原本的数据
        System.out.println(repeatStringList);
        //收集成list(不会去重)
        List<String> list = repeatStringList.stream().collect(Collectors.toList());
        //收集成set(因为set不允许重复数据，所以会去重)
        Set<String> set = repeatStringList.stream().collect(Collectors.toSet());
        System.out.println(list);
        System.out.println(set);
    }

输出

[张无忌, 张无忌, 赵敏, 赵敏, 张三丰]
[张无忌, 张无忌, 赵敏, 赵敏, 张三丰]
[张三丰, 赵敏, 张无忌]

收集成map

    /**
     * collect - 收集数据，放入map
     * 收集成集合或者set
     *
     * @return
     * @throws IOException
     */
    @GetMapping("/collectToMap")
    public void collectToMap() {
        List<String> nameAgeStringList = createListService.getNameAgeStringList();
        //打印原本的数据
        System.out.println(nameAgeStringList);

        Map<String, Integer> collect = nameAgeStringList.stream()
                .collect(Collectors.toMap(
                        s ->s.split("-")[0] //键的生成规则
                        ,
                        s -> Integer.valueOf(s.split("-")[1]) //值的生成规则
                ));
        System.out.println(collect);
    }

输出

[张无忌-24, 赵敏-20, 张三丰-87]
{张三丰=87, 赵敏=20, 张无忌=24}

三.使用汇总

apiPost文档：https://console-docs.apipost.cn/preview/fe570976875b98f3/d41543b18f9cf1e9

1.过滤


    /**
     * 过滤筛选
     */
    @GetMapping("/filter")
    public void filter() {
        List<Actor> actorList = createListService.getActorList();
        //原本的集合
        // Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25)
        // Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5)
        // Actor(name=雷布斯, age=35, address=金水区, companyName=小米,asset=750010.25)
        // Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)
        // Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25)
        System.out.println(actorList);

        /**
         * 1.过滤出满足条件的数据
         */
        List<Actor> filter = actorList
                .stream()
                .filter(s -> "网易".equals(s.getCompanyName()))
                .collect(Collectors.toList());
        System.out.println("公司名为网易的是：");
        //结果：Actor(name=李斯, age=25, address=惠济区, companyName=网易)
        System.out.println(filter);
        System.out.println("==============================================");
        /**
         * 2.统计出满足条件的个数
         */
        long count = actorList
                .stream()
                .filter(s -> "网易".equals(s.getCompanyName()))
                .count();
        //满足条件的个数为：1
        System.out.println("满足条件的个数为：" + count);
        System.out.println("==============================================");
    }

输出

[Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25), Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5), Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25), Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87), Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25)]
公司名为网易的是：
[Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5)]
==============================================
满足条件的个数为：1
==============================================

2.截取

   /**
     * 截取
     */
    @GetMapping("/skipAndLimit")
    public R skipAndLimit() {
        List<Actor> actorList = createListService.getActorList();
        /**
         * 3.截取前几个/跳过前几个
         *  可以结合使用，搭配出取指定连续几个的效果
         */
        List<Actor> skipAndLimit = actorList
                .stream()
                //跳过前两个，然后截取剩余的前两个，达到只取中间两个的效果
                .skip(2)
                .limit(2)
                .collect(Collectors.toList());
        System.out.println("只取中间两个：");
        //结果：Actor(name=雷布斯, age=35, address=金水区, companyName=小米),
        //     Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原)
        System.out.println(skipAndLimit);
        return R.ok(skipAndLimit);
    }

输出

只取中间两个：
[Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25), Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)]

3.排序

  /**
     * 排序
     */
    @GetMapping("/sort")
    public R sort() {
        List<Actor> actorList = createListService.getActorList();
        /**
         * 排序
         *
         *   ①.reversed()方法表示倒序，不加默认正序
         *   ②如果有空值，需要使用Comparator.nullsLast(Integer::compareTo)来处理，指定空值是放最前还是最后，且需要指明数据类型
         *   ③如果有多个比较的字段，使用.thenComparing()即可，内部参数与.comparing()相同
         *   ④排序后取前几名，可以使用
         */
        List<Actor> sortList = actorList
                .stream()
                //先按照年龄倒序，年龄相同的比较名称
                .sorted(Comparator.comparing(Actor::getAge, Comparator.nullsLast(Integer::compareTo)).reversed()
                        .thenComparing(Actor::getName, Comparator.nullsLast(String::compareTo)).reversed()
                )
                .collect(Collectors.toList());
        System.out.println("先按照年龄降序，年龄相同的比较名称：");
        System.out.println(sortList);
        List<Actor> sortListLimit = actorList
                .stream()
                .sorted(Comparator.comparing(Actor::getAge, Comparator.nullsLast(Integer::compareTo)).reversed()
                        .thenComparing(Actor::getName, Comparator.nullsLast(String::compareTo)).reversed()
                )
                //只取前两名
                .limit(2)
                .collect(Collectors.toList());
        System.out.println("只取前两名：");
        System.out.println(sortListLimit);
        return R.ok(sortList);
    }

输出

先按照年龄降序，年龄相同的比较名称：
[Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25), Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25), Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5), Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25), Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)]

只取前两名：
[Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25), Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25)]

4.去重

   /**
     * 去重
     */
    @GetMapping("/distinct")
    public void distinct() {
        List<Actor> actorList = createListService.getActorList();
        /**
         * 1.去重得出数组
         * 原生的去重只针对数组生效，
         *   ①如果需要对象集合中某个字段的去重数组集合，可以先把该字段通过数据转换拿出来，然后再去重收集
         *
         */
        List<Integer> ageDistinct = actorList
                .stream()
                //先通过数据类型转换，把所有的该字段拿出来
                .map(Actor::getAge)
                //然后去重收集
                .distinct()
                .collect(Collectors.toList());
        System.out.println("去重后的年龄数组集合：");
        //结果：[12, 25, 35, 20]
        System.out.println(ageDistinct);
        System.out.println("==============================================");

        /**
         *2.去重得出对象集合
         *  如果想要根据对象集合中某个字段的去重，但依旧需要对象集合，
         *  需要在收集的时候使用到 Collectors.collectingAndThen()方法
         *  该方法的意思是：先进行结果集的收集，然后将收集到的结果集进行下一步的处理
         *  需要两个参数，参数一是对数组进行的操作；参数二是返回成什么样的数据类型
         *  核心思想是先把集合放入 treeSet，因为TreeSet天生不允许重复元素，因此可以进行去重
         *  然后利用参数二进行数据类型转换返回
         */
        ArrayList<Actor> ageDistinctList = actorList
                .stream()
                .collect(Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Actor::getAge)))
                        ,
                        ArrayList::new
                ));
        System.out.println("根据age去重后的对象集合：");
        System.out.println(ageDistinctList);
        System.out.println("==============================================");
    }

输出

去重后的年龄数组集合：
[12, 25, 35, 20]
==============================================
根据age去重后的对象集合：
[Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25), Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25), Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5), Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25)]
==============================================

5.判断匹配

  /**
     * 判断检查
     */
    @GetMapping("/check")
    public void check() {
        List<Actor> actorList = createListService.getActorList();
        /**
         * 判断集合中是否有满足条件的数据，任意一个元素匹配成功，返回true，一个都没有就返回false
         */
        boolean a = actorList.stream().anyMatch(s -> "网易".equals(s.getCompanyName()));
        System.out.println("集合中是否有公司为 网易 的：" + a);
        /**
         * 判断集合中是否全部元素都满足条件,所有元素都满足才返回true,其余情况返回false
         */
        boolean b = actorList.stream().allMatch(s -> "网易".equals(s.getCompanyName()));
        System.out.println("集合中是否所有公司都为 网易 ：" + b);
        /**
         * 断集合中是否全部元素都 不 满足条件，所有元素都不满足才返回true,其余情况返回false
         * 与allMatch是相反的用法
         */
        boolean c = actorList.stream().noneMatch(s -> "网易".equals(s.getCompanyName()));
        System.out.println("集合中是否所有公司都不为 网易 ：" + c);
    }

输出

集合中是否有公司为 网易 的：true
集合中是否所有公司都为 网易 ：false
集合中是否所有公司都不为 网易 ：false

6.聚合函数

   /**
     * 聚合函数
     */
    @GetMapping("/aggFunction")
    public void aggFunction() {
        List<Actor> actorList = createListService.getActorList();
        /**
         * 最大值最小值
         * int类型、BigDecimal类型都适用
         */
        Optional<Actor> maxAge = actorList
                .stream()
                .collect(Collectors.maxBy(Comparator.comparing(Actor::getAge)));
        Optional<Actor> minAge = actorList
                .stream()
                .collect(Collectors.minBy(Comparator.comparing(Actor::getAge)));
        Optional<Actor> maxAsset = actorList
                .stream()
                .collect(Collectors.maxBy(Comparator.comparing(Actor::getAsset)));
        Optional<Actor> minAsset = actorList
                .stream()
                .collect(Collectors.minBy(Comparator.comparing(Actor::getAsset)));
        System.out.println("最大年龄是：" + maxAge + ",最小年龄是：" + minAge);
        System.out.println("最多财产是：" + maxAsset + ",最少财产是：" + minAsset);

        /**
         * 求和，求平均值 (int、double、long)
         */
        Integer sumAge = actorList
                .stream()
                .collect(Collectors.summingInt(Actor::getAge));
        Double averAge = actorList
                .stream()
                .collect(Collectors.averagingInt(Actor::getAge));
        System.out.println("年龄和加起来：" + sumAge);
        System.out.println("年龄平均起来：" + averAge);
        /**
         * 求和 （BigDecimal）
         */
        BigDecimal reduce = actorList
                .stream()
                .map(Actor::getAsset)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        System.out.println("总财产加起来：" + reduce);
        /**
         * 求平均值 （BigDecimal）
         * 平均值只能通过先求出合，然后除以总数量来计算了
         */
        BigDecimal average = actorList.stream()
                .map(vo -> ObjectUtils.isEmpty(vo.getAsset()) ? new BigDecimal(0) : vo.getAsset())
                .reduce(BigDecimal.ZERO, BigDecimal::add)
                .divide(BigDecimal.valueOf(actorList.size()), 2, BigDecimal.ROUND_HALF_UP);
        System.out.println("总财产的平均值：" + average);

        /**
         * 一次计算 总数、总和、最小值、最大值、平均值
         */
        IntSummaryStatistics collect = actorList
                .stream()
                .collect(Collectors.summarizingInt(Actor::getAge));
        //IntSummaryStatistics{count=5, sum=127, min=12, average=25.400000, max=35}
        System.out.println(collect);
    }

输出

最大年龄是：Optional[Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25)],
最小年龄是：Optional[Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25)]

最多财产是：Optional[Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25)],
最少财产是：Optional[Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)]

年龄和加起来：127
年龄平均起来：25.4

总财产加起来：2288432.12
总财产的平均值：457686.42

IntSummaryStatistics{count=5, sum=127, min=12, average=25.400000, max=35}

7.拼接

  /**
     * 拼接
     */
    @GetMapping("/join")
    public R join() {
        List<Actor> actorList = createListService.getActorList();
        String joinName = actorList
                .stream()
                .map(Actor::getName)
                .collect(Collectors.joining(","));
        // 王刚,李斯,雷布斯,努尔哈赤,雨花石
        System.out.println("将名称以 ， 连接：" + joinName);

        String joinNameWithPre = actorList
                .stream()
                .map(Actor::getName)
                .collect(Collectors.joining(",", "[", "]"));
        // [王刚,李斯,雷布斯,努尔哈赤,雨花石]
        System.out.println("将名称以 前缀[ 后缀] 连接符, 连接：" + joinNameWithPre);
        return R.ok(joinNameWithPre);
    }

输出

将名称以 ， 连接：王刚,李斯,雷布斯,努尔哈赤,雨花石
将名称以 前缀[ 后缀] 连接符, 连接：[王刚,李斯,雷布斯,努尔哈赤,雨花石]

8.分组

    /**
     * 分组
     */
    @GetMapping("/group")
    public R group() {
        List<Actor> actorList = createListService.getActorList();
        /**
         * 分组成为map
         */
        Map<Integer, List<Actor>> ageListMap = actorList
                .stream()
                .collect(Collectors.groupingBy(Actor::getAge));
        System.out.println("根据年龄分组：" + ageListMap);
        return R.ok(actorList);
    }

输出

根据年龄分组：{35=[Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25), Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)], 20=[Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25)], 25=[Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5)], 12=[Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25)]}

9.集合转map

 /**
     * 集合转map
     */
    @GetMapping("/changeToMap")
    public R changeToMap() {
        List<Actor> actorList = createListService.getActorList();
        /**
         * 转成 字段-实体的map
         */
        Map<String, Actor> nameObjectMap = actorList
                .stream()
                .collect(Collectors.toMap(Actor::getName, Function.identity()));
        //{雷布斯=Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25),
        // 王刚=Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25),
        // 雨花石=Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25),
        // 李斯=Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5),
        // 努尔哈赤=Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)}
        System.out.println(nameObjectMap);
        /**
         * 转成 字段-字段的map
         */
        Map<String, String> nameCompanyMap = actorList
                .stream()
                .collect(Collectors.toMap(
                        //键的生成
                        Actor::getName
                        ,
                        //值的生成
                        Actor::getCompanyName));
        //{雷布斯=小米, 王刚=阿里巴巴, 雨花石=花花牛, 李斯=网易, 努尔哈赤=草原牧原}
        System.out.println(nameCompanyMap);
        return R.ok(nameObjectMap);
    }

输出

{雷布斯=Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25), 王刚=Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25), 雨花石=Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25), 李斯=Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5), 努尔哈赤=Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)}


{雷布斯=小米, 王刚=阿里巴巴, 雨花石=花花牛, 李斯=网易, 努尔哈赤=草原牧原}

10.集合转其他对象的集合

   /**
     * 集合转成另外一个实体的集合
     */
    @GetMapping("/changeToAnotherList")
    public R changeToAnotherList() {
        List<Actor> actorList = createListService.getActorList();
        List<UserInfo> userInfoList = actorList
                .stream()
                .map(o -> {
                    UserInfo userInfo = new UserInfo();
                    userInfo.setUserName(o.getName());
                    return userInfo;
                })
                .collect(Collectors.toList());
        System.out.println(userInfoList);
        return R.ok(userInfoList);
    }

输出

[UserInfo(id=null, userName=王刚, passWord=null, tenantId=null, deleted=null, version=null, deptId=null, dept=null, roles=null, permissions=null), UserInfo(id=null, userName=李斯, passWord=null, tenantId=null, deleted=null, version=null, deptId=null, dept=null, roles=null, permissions=null), UserInfo(id=null, userName=雷布斯, passWord=null, tenantId=null, deleted=null, version=null, deptId=null, dept=null, roles=null, permissions=null), UserInfo(id=null, userName=努尔哈赤, passWord=null, tenantId=null, deleted=null, version=null, deptId=null, dept=null, roles=null, permissions=null), UserInfo(id=null, userName=雨花石, passWord=null, tenantId=null, deleted=null, version=null, deptId=null, dept=null, roles=null, permissions=null)]

11.根据对象中某一个字段对集合进行去重

    /**
     * 根据集合中某一个字段进行去重
     * <p>
     * <li>
     * 1、Collectors.toMap()方法的第一个参数 Actor::getAddress 提供了键的函数，
     * 第二个参数Function.identity()提供了值的函数，
     * 第三个参数(existing, replacement) -> existing定义了当键冲突时如何选择值。
     * </li>
     * <li>
     * 2、最终，我们使用collectingAndThen()将生成的Map转换回List。
     * </li>
     * </p>
     */
    @GetMapping("/distinctByParam")
    public void distinctByParam() {
        //1.原集合
        List<Actor> actorList = createListService.getActorList();
        System.out.println("原集合：");
        for (Actor actor : actorList) {
            System.out.println(actor);
        }
        //2.进行过滤
        List<Actor> distinctItems = actorList.stream()
                .collect(
                        //3、Map转换回List
                        Collectors.collectingAndThen(
                                //1、提供过滤的键值，以及冲突时保留原则(这里是保留先进的)
                                Collectors.toMap(Actor::getAddress, Function.identity(), (existing, replacement) -> existing),
                                //2、指定生成的数据结构为map
                                map -> new ArrayList<>(map.values())
                        )
                );
        System.out.println("去重后的集合：");
        for (Actor distinctItem : distinctItems) {
            System.out.println(distinctItem);
        }
    }

输出

原集合：
Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25)
Actor(name=李斯, age=25, address=惠济区, companyName=网易, asset=250500.5)
Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25)
Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)
Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25)
去重后的集合：
Actor(name=雨花石, age=20, address=惠济区, companyName=花花牛, asset=1050010.25)
Actor(name=努尔哈赤, age=35, address=管城区, companyName=草原牧原, asset=87910.87)
Actor(name=雷布斯, age=35, address=金水区, companyName=小米, asset=750010.25)
Actor(name=王刚, age=12, address=中原区, companyName=阿里巴巴, asset=150000.25)