java8 stream接口终端操作 collect操作

柔情只为你懂 2021-09-27 04:04 444阅读 0赞

在之前，我们有说到，java8中的stream操作，分为中间操作和终端操作，在终端操作中，前面也看到了归约的方式，这篇主要是也说的归约操作的方式collect，收集器操作，收集器操作，可以当做是一种更高级的归约操作；

先看下stream中的collect操作

<R> R collect(Supplier<R> supplier,BiConsumer<R, ? super T> accumulator,BiConsumer<R, R> combiner);
    	<R, A> R collect(Collector<? super T, A, R> collector);

第一个，是传入3个参数的抽象方法，

第二个只有一个参数的先看下stream中的collect操作Collectors静态工厂类，而在这个静态工厂类中，大部分的实现，都是调用的三个参数的方法，几乎满足了我们日常中所有的操作；所以说，我们只看下，这个静态工厂类中，有哪些实现；

![70][]![70 1][]

在java8实战中，有列举出来，大家可以自己看下介绍，下面，我们通过代码，做个演示；

package com.meinergy.vppd.business.api.test;
    
    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.IntSummaryStatistics;
    import java.util.List;
    import java.util.Map;
    import java.util.Optional;
    import java.util.Set;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    
    import org.junit.Test;
    
    public class TestJava8 {
        public static List<Emp> list = new ArrayList<>();
        static {
            list.add(new Emp("上海", "小名", 17));
            list.add(new Emp("北京", "小红", 18));
            list.add(new Emp("深圳", "小蓝", 19));
            list.add(new Emp("广州", "小灰", 20));
            list.add(new Emp("杭州", "小黄", 21));
            list.add(new Emp("贵阳", "小白", 22));
        }
    
        @Test
        public void test1() {
            // 转list
            List<String> names = list.stream().map(emp -> emp.getName()).collect(Collectors.toList());
            // 转set
            Set<String> address = list.stream().map(emp -> emp.getName()).collect(Collectors.toSet());
            // 转map，需要指定key和value，Function.identity()表示当前的Emp对象本身
            Map<String, Emp> map = list.stream().collect(Collectors.toMap(Emp::getName, Function.identity()));
            // 计算元素中的个数
            Long count = list.stream().collect(Collectors.counting());
            // 数据求和 summingInt summingLong，summingDouble
            Integer sumAges = list.stream().collect(Collectors.summingInt(Emp::getAge));
            // 平均值 averagingInt,averagingDouble,averagingLong
            Double aveAges = list.stream().collect(Collectors.averagingInt(Emp::getAge));
    
            // 综合处理的，求最大值，最小值，平均值，求和操作
            // summarizingInt，summarizingLong,summarizingDouble
            IntSummaryStatistics intSummary = list.stream().collect(Collectors.summarizingInt(Emp::getAge));
            System.out.println(intSummary.getAverage());// 19.5
            System.out.println(intSummary.getMax());// 22
            System.out.println(intSummary.getMin());// 17
            System.out.println(intSummary.getSum());// 117
    
            // 连接字符串,当然也可以使用重载的方法，加上一些前缀，后缀和中间分隔符
            String strEmp = list.stream().map(emp -> emp.getName()).collect(Collectors.joining());
            String strEmp1 = list.stream().map(emp -> emp.getName()).collect(Collectors.joining("-中间的分隔符-"));
            String strEmp2 = list.stream().map(emp -> emp.getName()).collect(Collectors.joining("-中间的分隔符-", "前缀*", "&后缀"));
            System.out.println(strEmp);// 小名小红小蓝小灰小黄小白
            // 小名-中间的分隔符-小红-中间的分隔符-小蓝-中间的分隔符-小灰-中间的分隔符-小黄-中间的分隔符-小白
            System.out.println(strEmp1);
            // 前缀*小名-中间的分隔符-小红-中间的分隔符-小蓝-中间的分隔符-小灰-中间的分隔符-小黄-中间的分隔符-小白&后缀
            System.out.println(strEmp2);
            // maxBy 按照比较器中的比较结果刷选 最大值
            Optional<Integer> maxAge = list.stream().map(emp -> emp.getAge())
                    .collect(Collectors.maxBy(Comparator.comparing(Function.identity())));
            // 最小值
            Optional<Integer> minAge = list.stream().map(emp -> emp.getAge())
                    .collect(Collectors.minBy(Comparator.comparing(Function.identity())));
            System.out.println("max:" + maxAge);
            System.out.println("min:" + minAge);
    
            // 归约操作
            list.stream().map(emp -> emp.getAge()).collect(Collectors.reducing((x, y) -> x + y));
            list.stream().map(emp -> emp.getAge()).collect(Collectors.reducing(0, (x, y) -> x + y));
            // 分操作 groupingBy 根据地址，把原list进行分组
            Map<String, List<Emp>> mapGroup = list.stream().collect(Collectors.groupingBy(Emp::getAddress));
            // partitioningBy 分区操作 需要根据类型指定判断分区
            Map<Boolean, List<Integer>> partitioningMap = list.stream().map(emp -> emp.getAge())
                    .collect(Collectors.partitioningBy(emp -> emp > 20));
    
        }
    
        static class Emp {
            private String address;
    
            private String name;
    
            private Integer age;
    
            public Emp() {
    
            }
    
            public Emp(String address) {
                this.address = address;
            }
    
            public Emp(String name, Integer age) {
                this.name = name;
                this.age = age;
            }
    
            public Emp(String address, String name, Integer age) {
                super();
                this.address = address;
                this.name = name;
                this.age = age;
            }
    
            public String getAddress() {
                return address;
            }
    
            public void setAddress(String address) {
                this.address = address;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public Integer getAge() {
                return age;
            }
    
            public void setAge(Integer age) {
                this.age = age;
            }
    
            @Override
            public String toString() {
                return "Emp [address=" + address + ", name=" + name + ", age=" + age + "]";
            }
    
        }
    }

先介绍在这里，大家对java8的的函数式接口，以及lambda表达式的写法，有看不懂的，可以参看我之前的文章

## 1.lambda表达式 ##

[《java8 Lambda表达式简介》][java8 Lambda]

[《java8 lambda表达式，方法的引用以及构造器的引用》][java8 lambda]

### 2.函数式接口 ###

[《java8 函数式接口简介》][java8]

[《JAVA8 Function接口以及同类型的特化的接口》][JAVA8 Function]

[《JAVA8 Consumer接口》][JAVA8 Consumer]

[《JAVA8 Supplier接口》][JAVA8 Supplier]

[《JAVA8 UnaryOperator接口》][JAVA8 UnaryOperator]

[《JAVA8 BiConsumer 接口》][JAVA8 BiConsumer]

3.stream接口操作

[《java8 Stream接口简介》][java8 Stream]

[《 java8 Stream-创建流的几种方式》][java8 Stream-]

[《JAVA8 stream接口 中间操作和终端操作》][JAVA8 stream_]

[《JAVA8 Stream接口，map操作，filter操作，flatMap操作》][JAVA8 Stream_map_filter_flatMap]

[《JAVA8 stream接口 distinct，sorted，peek，limit，skip》][JAVA8 stream_ distinct_sorted_peek_limit_skip]

[《java8 stream接口 终端操作 forEachOrdered和forEach》][java8 stream_ _ forEachOrdered_forEach]

[《java8 stream接口 终端操作 toArray操作》][java8 stream_ _ toArray]

[《java8 stream接口 终端操作 min，max，findFirst，findAny操作》][java8 stream_ _ min_max_findFirst_findAny]

[《java8 stream接口终端操作 count，anyMatch，allMatch，noneMatch》][java8 stream_ count_anyMatch_allMatch_noneMatch]

[《java8 srteam接口终端操作reduce操作》][java8 srteam_reduce]

[《java8 stream接口 终端操作 collect操作》][java8 stream_ _ collect]

4.其他部分

[《java8 Optional静态类简介，以及用法》][java8 Optional]

[70]: https://img-blog.csdn.net/20180715145937380?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4NDEwMjgz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: /images/20210923/5b08ec15ecea451fa05d05d5ce9b8f12.png
[java8 Lambda]: https://blog.csdn.net/qq_28410283/article/details/80961022
[java8 lambda]: https://blog.csdn.net/qq_28410283/article/details/80963351
[java8]: https://blog.csdn.net/qq_28410283/article/details/80962325
[JAVA8 Function]: https://blog.csdn.net/qq_28410283/article/details/80615629
[JAVA8 Consumer]: https://blog.csdn.net/qq_28410283/article/details/80618456
[JAVA8 Supplier]: https://blog.csdn.net/qq_28410283/article/details/80625482
[JAVA8 UnaryOperator]: https://blog.csdn.net/qq_28410283/article/details/80634319
[JAVA8 BiConsumer]: https://blog.csdn.net/qq_28410283/article/details/80704487
[java8 Stream]: https://blog.csdn.net/qq_28410283/article/details/80633292
[java8 Stream-]: https://blog.csdn.net/qq_28410283/article/details/80633710
[JAVA8 stream_]: https://blog.csdn.net/qq_28410283/article/details/80634725
[JAVA8 Stream_map_filter_flatMap]: https://blog.csdn.net/qq_28410283/article/details/80642786
[JAVA8 stream_ distinct_sorted_peek_limit_skip]: https://blog.csdn.net/qq_28410283/article/details/80643711
[java8 stream_ _ forEachOrdered_forEach]: https://blog.csdn.net/qq_28410283/article/details/80782808
[java8 stream_ _ toArray]: https://blog.csdn.net/qq_28410283/article/details/80783286
[java8 stream_ _ min_max_findFirst_findAny]: https://blog.csdn.net/qq_28410283/article/details/80783505
[java8 stream_ count_anyMatch_allMatch_noneMatch]: https://blog.csdn.net/qq_28410283/article/details/80783946
[java8 srteam_reduce]: https://blog.csdn.net/qq_28410283/article/details/80873910
[java8 stream_ _ collect]: https://blog.csdn.net/qq_28410283/article/details/81052881
[java8 Optional]: https://blog.csdn.net/qq_28410283/article/details/80952768