Stream流处理集合常用方式

主要介绍操作两种类型List<Integer>以及List<Person>，使用steam流可使实现功能代码更加简洁，下面都是实战项目中常用的几种操作

示例数据初始化

    /**
     * 初始示例数据
     * List<Integer>
     * List<Person>
     */
    private static List<Integer> numList = new ArrayList<>(4);
    private static List<Person> personList = new ArrayList<>(4);

    @Getter
    @Setter
    @ToString
    static class Person {
        private String name;
        private int age;
        private String dept;

        Person(String name, int age, String dept) {
            this.name = name;
            this.age = age;
            this.dept = dept;
        }
    }

    static {
        numList.add(1);
        numList.add(2);
        numList.add(3);
        numList.add(3);

        personList.add(new Person("老王", 11, "开发部"));
        personList.add(new Person("老老王王", 11, "开发部"));
        personList.add(new Person("老李", 12, "开发部"));
        personList.add(new Person("老张", 13, "产品部"));
    }

一、使用stream流对List<Integer>进行去重，求和，大小值，过滤，排序，平均值

1.1 去重
    /**
     * 去重
     * params List<Integer>
     */
    @Test
    public void streamTest_1() {
        List<Integer> result = numList.stream().distinct().collect(Collectors.toList());
        result.forEach(System.out::println);
    }

输出结果：

1
2
3
1.2 求和
    /**
     * 求和
     * params List<Integer>
     */
    @Test
    public void streamTest_2() {
        long result = numList.stream().mapToInt(value -> value).sum();
        System.out.println(result);
    }

输出结果：

9
1.3 最大值
    /**
     * 最大
     * params List<Integer>
     *
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_3() {
        Optional<Integer> max = numList.stream().max(Comparator.comparing(value -> value));
        if(max.isPresent()){
            int result = max.get();
            System.out.println(result);
        }
    }

输出结果：

3
1.4 最小值
    /**
     * 最小
     * params List<Integer>
     *
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_4() {
        Optional<Integer> min = numList.stream().min(Comparator.comparing(value -> value));
        if(min.isPresent()){
            int result = min.get();
            System.out.println(result);
        }
    }

输出结果：

1
1.5 过滤
    /**
     * 过滤
     * params List<Integer>
     *
     * 条件 将3的元素筛选出来
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_5() {
        List<Integer> result = numList.stream().filter(value -> value == 3).collect(Collectors.toList());
        System.out.println(result);
    }

输出结果：

[3, 3]
1.6 排序（从小到大）
    /**
     * 排序
     * params List<Integer>
     *
     * 条件 从小到大
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_6() {
        List<Integer> result = numList.stream()
                .sorted(Comparator.comparing(value -> value)).collect(Collectors.toList());
        System.out.println(result);
    }

输出结果：

[1, 2, 3, 3]
1.7 排序（从大到小）
    /**
     * 排序
     * params List<Integer>
     *
     * 条件 从大到小
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_7() {
        List<Integer> result = numList.stream()
                .sorted(Comparator.comparing(value -> value,Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println(result);
    }

输出结果：

[3, 3, 2, 1]
1.8 求平均值
    /**
     * 求平均值
     * params List<Integer>
     */
    @Test
    public void streamTest_8() {
        OptionalDouble average = numList.stream().mapToInt(value -> value).average();
        if (average.isPresent()){
            System.out.println(average.getAsDouble());
        }
    }

输出结果：

2.25

二、使用stream流对List<Person>进行去重，求和，大小值，过滤，排序，平均值，分组

2.1 去重（单属性）
    /**
     * 去重
     * params List<Person>
     * 条件 去除dept相同的
     *
     * Collectors.collectingAndThen 转换结果返回类型
     * TreeSet 包含有序的且没有重复元素的集合
     *
     */
    @Test
    public void streamTest_9() {

        System.out.println("处理前：");
        personList.forEach(System.out::println);

        List<Person> result = personList.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(
                        Comparator.comparing(
                                Person::getDept))), ArrayList::new));
        //输出结果
        System.out.println("处理后：");
        result.forEach(System.out::println);
    }

输出结果：

处理前：
GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老老王王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老李, age=12, dept=开发部)
GoodsQueryTest.Person(name=老张, age=13, dept=产品部)
处理后：
GoodsQueryTest.Person(name=老张, age=13, dept=产品部)
GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
2.2 去重（多属性）
    /**
     * 去重
     * params List<Person>
     * 条件 去除age且dept相同的
     *
     */
    @Test
    public void streamTest_10() {

        System.out.println("处理前：");
        personList.forEach(System.out::println);

        List<Person> result = personList.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(
                        Comparator.comparing(person -> person.getAge() + "," + person.getDept()))), ArrayList::new));
        //输出结果
        System.out.println("处理后：");
        result.forEach(System.out::println);
    }

输出结果：

处理前：
GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老老王王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老李, age=12, dept=开发部)
GoodsQueryTest.Person(name=老张, age=13, dept=产品部)
处理后：
GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老李, age=12, dept=开发部)
GoodsQueryTest.Person(name=老张, age=13, dept=产品部)
2.3 求和
    /**
     * 求和
     * params List<Person>
     * 条件 age总和
     *
     */
    @Test
    public void streamTest_11() {
        int sum = personList.stream().mapToInt(Person::getAge).sum();
        System.out.println(sum);
    }

输出结果：

47
2.4 最大
    /**
     * 最大
     * params List<Person>
     * 条件 age最大
     *
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_12() {
        Optional<Person> personOptional = personList.stream().max(Comparator.comparing(Person::getAge));
        personOptional.ifPresent(person -> System.out.println(person.toString()));

    }

输出结果：

GoodsQueryTest.Person(name=老张, age=13, dept=产品部)
2.5 最小
    /**
     * 最小
     * params List<Person>
     * 条件 age最小
     *
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_13() {
        Optional<Person> personOptional = personList.stream().min(Comparator.comparing(Person::getAge));
        personOptional.ifPresent(person -> System.out.println(person.toString()));

    }

输出结果：

GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
2.6 过滤
    /**
     * 过滤
     * params List<Person>
     * 条件 筛选age等于11的数据
     *
     */
    @Test
    public void streamTest_14() {
        List<Person> result = personList.stream().filter(person -> person.getAge() == 11).collect(Collectors.toList());
        result.forEach(System.out::println);
    }

输出结果：

GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老老王王, age=11, dept=开发部)
2.7 排序（从小到大）
 /**
     * 排序
     * params List<Person>
     *
     * 条件 按age从小到大
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_15() {
        List<Person> result = personList.stream().sorted(Comparator.comparing(Person::getAge)).collect(Collectors.toList());
        result.forEach(System.out::println);
    }

输出结果：

GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老老王王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老李, age=12, dept=开发部)
GoodsQueryTest.Person(name=老张, age=13, dept=产品部)
2.8 排序（从大到小）
    /**
     * 排序
     * params List<Person>
     *
     * 条件 按age从大到小
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_16() {
        List<Person> result
                = personList.stream().sorted(Comparator.comparing(Person::getAge,Comparator.reverseOrder())).collect(Collectors.toList());
        result.forEach(System.out::println);
    }

输出结果：

GoodsQueryTest.Person(name=老张, age=13, dept=产品部)
GoodsQueryTest.Person(name=老李, age=12, dept=开发部)
GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老老王王, age=11, dept=开发部)
2.9 排序（多字段排序）
     /**
     * 多字段排序
     * params List<Person>
     *
     * 条件 先按age从大到小，再按dept从大到小
     * Comparator.comparing 元素为null会抛出异常
     */
    @Test
    public void streamTest_17() {
        List<Person> result
                = personList.stream().sorted(Comparator
                .comparing(Person::getAge,Comparator.reverseOrder())
                .thenComparing(Person::getDept,Comparator.reverseOrder())).collect(Collectors.toList());
        result.forEach(System.out::println);
    }

输出结果：

GoodsQueryTest.Person(name=老张, age=13, dept=产品部)
GoodsQueryTest.Person(name=老李, age=12, dept=开发部)
GoodsQueryTest.Person(name=老王, age=11, dept=开发部)
GoodsQueryTest.Person(name=老老王王, age=11, dept=开发部)
2.10 平均值
    /**
     * 平均值
     * params List<Person>
     *
     * 条件 按age求平均值
     */
    @Test
    public void streamTest_18() {
        OptionalDouble average = personList.stream().mapToInt(Person::getAge).average();
        if(average.isPresent()){
            System.out.println(average.getAsDouble());
        }
    }

输出结果：

    11.75
2.11 分组
/**
     * 分组
     * params List<Person>
     *
     * 条件 age相同的分组（以age为key，分组记录为value）
     */
    @Test
    public void streamTest_19() {
        Map<Integer, List<Person>> result = personList.stream().collect(Collectors.groupingBy(Person::getAge));

//        for (Map.Entry<Integer, List<Person>> integerListEntry : result.entrySet()) {
//            Integer key = integerListEntry.getKey();
//            List<Person> value = integerListEntry.getValue();
//            System.out.println(key + ": " + value);
//        }
        //上面输出可简写如下：
        result.forEach((key, value) -> System.out.println(key + " : " + value));
    }

输出结果：

11: [GoodsQueryTest.Person(name=老王, age=11, dept=开发部), GoodsQueryTest.Person(name=老老王王, age=11, dept=开发部)]
12: [GoodsQueryTest.Person(name=老李, age=12, dept=开发部)]
13: [GoodsQueryTest.Person(name=老张, age=13, dept=产品部)]

----------------- 文章如有问题，请下方回复指出，感谢查阅😁 -----------------

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
禁止转载，如需转载请通过简信或评论联系作者。

推荐阅读更多精彩内容