Collectors 基本使用

首先我们先了解一下，Collectors可以帮我们完成的事情，例如：分组、排序（支持多字段排序）、最大值、最小值、平均值，简单的来说，以前我们在数据上面用sql 去完成的聚合相关的操作，Collectors 都可以完成。ps：刚刚开始尝试写一些原创文章，写的不好，请大家见谅~

先准备数据

    private List<String> list = new ArrayList<>();

    List<Users> users;

    @Before
    public void load() {
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");

        users = Arrays.asList(new Users(1, "张三", 18),
                new Users(2, "李四", 30),
                new Users(3, "王五", 20),
                new Users(4, "赵六", 18));

    }

分组

    @Test
    public void groupingBy() {
        users.stream().collect(Collectors.groupingBy(Users::getAge)).forEach((key, value) -> {
            System.out.println(key + "  ---" + value);
        });

    }

分组,然后取最大的值

  
    @Test
    public void groupingByMax() {

        //分组后去最大值
        Map<Integer, Optional<Users>> collect = users.stream().collect(Collectors.groupingBy(Users::getAge, Collectors.maxBy(Comparator.comparing(Users::getId))));

        //分组后去最小值
        Map<Integer, Optional<Users>> collect2 = users.stream().collect(Collectors.groupingBy(Users::getAge, Collectors.minBy(Comparator.comparing(Users::getId))));

        collect.forEach((key, value) -> {
            System.out.println("key " + key + "          " + "value : " + value);
        });


        System.out.println("---------------------");

        collect2.forEach((key, value) -> {
            System.out.println("key " + key + "          " + "value : " + value);
        });

    }

分组后，把原始对象进行转换为新的对象

    @Test
    public void mapping() {

        Map<Integer, List<String>> collect = users.stream().collect(Collectors.groupingBy(Users::getAge, Collectors.mapping( item ->{
            
            //当然你这里也可以构建一个新的对象，进行返回
            return item.getName();
        }, Collectors.toList())));

        //   Map<Integer, List<Object>> collect = users.stream().collect(Collectors.groupingBy(Users::getAge, Collectors.mapping(item ->{ return Arrays.asList(item); }, Collectors.toList())));

        collect.forEach((key, value) -> {
            System.out.println("key : " + key + "value :" + value);
        });
    }

单字段进行排序

    /**
     * 单字段进行排序
     */
    @Test
    public void sort() {

        //倒序
        System.out.println("倒序");
        users.stream().sorted(Comparator.comparing(Users::getAge).reversed()).collect(Collectors.toList()).forEach(item -> {
            System.out.println(item.getAge());
        });

        System.out.println("升序");

        //升序
        users.stream().sorted(Comparator.comparing(Users::getAge)).collect(Collectors.toList()).forEach(item -> {
            System.out.println(item.getAge());
        });

    }

结果

image.png

多字段进行排序（comparator）

     /**
     * 排序 、多条件排序,注意事项，排序的字段不能为空
     */
    @Test
    public void comparator() {

        /**
         *
         * 手动控制排序（复杂业务的时候，可以采用该种方法）
         * 1、年龄倒叙
         * 2、id 升序
         *
         */
        Comparator<Users> usersComparator = Comparator.comparing(Users::getAge, (o1, o2) -> {
            //  倒叙
            return o2.compareTo(o1);
        }).thenComparing(Users::getId, (o1, o2) -> {
            // 升序
            return o1.compareTo(o2);
        });
        List<Users> collect = users.stream().sorted(usersComparator).collect(Collectors.toList());

        collect.forEach(item -> {
            System.out.println(item);
        });

        System.out.println("----------------------------------");

        /**
         *
         * 第二种排倒序方法
         * Comparator.reverseOrder 倒叙
         * Comparator.naturalOrder 升叙
         *
         * 1、年龄倒叙
         * 2、id 倒序
         *
         */
        Comparator<Users> usersComparator2 = Comparator.comparing(Users::getAge, Comparator.reverseOrder()).thenComparing(Users::getId,Comparator.reverseOrder());
        List<Users> collect2 = users.stream().sorted(usersComparator2).collect(Collectors.toList());

        collect2.forEach(item -> {
            System.out.println(item);
        });

    }

结果：

image.png