Stream流与Lambda表达式（二) Stream收集器 Collector接口

超、凢脫俗 2022-03-07 00:47 225阅读 0赞

## 一、Stream收集器 Collector接口 ##

package com.java.design.java8.Stream;
    
    import com.java.design.java8.entity.Student;
    import com.java.design.java8.entity.Students;
    import org.junit.Before;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.*;
    import java.util.stream.Collectors;
    
    
    /**
     * @author 陈杨
     */
    
    @SpringBootTest
    @RunWith(SpringRunner.class)
    public class CollectorDetail {
    
        private List<Student> students;
    
        @Before
        public void init() {
            students=new Students().init();
        }
    
        @Test
        public void testCollectorDetail() {
    
    
            //     Collect 收集器 ---- Collector接口
    
            //     T-->汇聚操作的元素类型 即流中元素类型
            //     A-->汇聚操作的可变累积类型
            //     R-->汇聚操作的结果类型
            //     public interface Collector<T, A, R>
    
            //     Collector接口   一种可变汇聚操作
            //                    将输入元素累积到可变结果容器中
            //                    在处理完所有输入元素后 可以选择将累积的结果转换为最终表示（可选操作）
            //                    归约操作支持串行与并行
            //     A  mutable reduction operation that  accumulates input elements into a mutable result container,
            //     optionally transforming  the accumulated result into a final representation after all input         elements
            //     have been processed.  Reduction operations can be performed either sequentially  or in parallel.
    
    
            //     Collectors 提供 Collector 汇聚实现  实际上是一个Collector工厂
            //     The class {@link Collectors}  provides implementations of many common mutable reductions.

## 二、Collector 接口组成 ##

//     Collector 由以下4个函数协同累积到容器 可选的执行最终转换
        //               supplier           创建一个新的结果容器
        //               accumulator累加器   将新数据元素合并到结果容器中
        //               combiner           合并结果容器  处理线程并发
        //               finisher           对容器执行可选的最终转换
        //
        //     A {@code Collector} is specified by four functions that work together to
        //     accumulate entries into a mutable result container, and optionally perform
        //     a final transform on the result.  They are:
        //           creation of a new result container ({@link #supplier()})
        //           incorporating a new data element into a result container ({@link #accumulator()})
        //           combining two result containers into one ({@link #combiner()})
        //           performing an optional final transform on the container ({@link #finisher()})

## 三、combiner ##

/*
             *     A function that accepts two partial results and merges them.  The
             *     combiner function may fold state from one argument into the other and
             *     return that, or may return a new result container.
             *
             *
             *     BinaryOperator<A> combiner();
             */
    
           /*     supplier创建单个结果容器-->accumulator调用累积功能-->partition结果--分区容器-->combiner合并分区容器
    
                  A sequential implementation of a reduction using a collector would
                  create a single result container using the supplier function, and invoke the
                  accumulator function once for each input element.  A parallel implementation
                  would partition the input, create a result container for each partition,
                  accumulate the contents of each partition into a subresult for that partition,
                  and then use the combiner function to merge the subresults into a combined
                  result.
            */

## 四、identity associativity 约束 ##

/*
           确保串行与并行结果的一致性，满足约束： identity  associativity
           To ensure that sequential and parallel executions produce equivalent
           results, the collector functions must satisfy an identity and an associativity constraints.
     */
    
    /*     identity 约束：
           对于任何部分累积的结果， 将其与空结果容器组合必须生成等效的结果
           a == combiner.apply(a, supplier.get())
    
           The identity constraint says that for any partially accumulated result,
           combining it with an empty result container must produce an equivalent
           result.  That is, for a partially accumulated result {@code a} that is the
           result of any series of accumulator and combiner invocations, {@code a} must
           be equivalent to {@code combiner.apply(a, supplier.get())}.
     */
    
    /*     associativity 约束：
           串行计算与并行拆分计算必须产生同等的结果
    
           The associativity constraint says that splitting the computation must
           produce an equivalent result.  That is, for any input elements {@code t1}
           and {@code t2}, the results {@code r1} and {@code r2} in the computation
           below must be equivalent:
    
             A a1 = supplier.get();
             accumulator.accept(a1, t1);
             accumulator.accept(a1, t2);
             R r1 = finisher.apply(a1);  // result without splitting
    
             A a2 = supplier.get();
             accumulator.accept(a2, t1);
             A a3 = supplier.get();
             accumulator.accept(a3, t2);
             R r2 = finisher.apply(combiner.apply(a2, a3));  // result with splitting
    
     */

## 五、reduction 汇聚 的实现方式 ##

//      reduction 汇聚 的实现方式
            //      list.stream().reduce()                        对象不可变
            //      list.stream().collect(Collectors.reducing())  对象可变
            //      单线程可以实现结果一致 但在多线程中就会出现错误
    
            /*
    
                     Libraries that implement reduction based on {@code Collector}, such as
                     {@link Stream#collect(Collector)}, must adhere to the following constraints:
    
    
                     传递给accumulator的第一个参数，传递给combiner的二个参数，传递给finisher的参数
                     必须是函数（supplier accumulator combiner）上一次调用结果
                     理解： 参数类型A
                     Supplier<A> supplier();
                     BiConsumer<A, T> accumulator();
                     BinaryOperator<A> combiner();
                     Function<A, R> finisher();
    
                     The first argument passed to the accumulator function, both
                     arguments passed to the combiner function, and the argument passed to the
                     finisher function must be the result of a previous invocation of the
                     result supplier, accumulator, or combiner functions
    
    
                    supplier accumulator combiner的实现结果-->
                    传递给下一次supplier accumulator combiner操作
                    或返还给汇聚操作的调用方
                    而不进行其他操作
                    The implementation should not do anything with the result of any of
                    the result supplier, accumulator, or combiner functions other than to
                    pass them again to the accumulator, combiner, or finisher functions,
                    or return them to the caller of the reduction operation
    
    
                    一个结果传递给combiner finisher而相同的对象没有从此函数中返回 这个结果不会再被使用
                    这个传入结果是被消费了 生成了新的对象
                     If a result is passed to the combiner or finisher
                     function, and the same object is not returned from that function, it is
                     never used again
    
    
                    一旦结果传递给combiner finisher 则不再会传递给accumulator
                    说明流中元素已经传递完全  accumulator任务已执行完毕
                    Once a result is passed to the combiner or finisher function, it
                    is never passed to the accumulator function again
    
                    非并发单线程
                    For non-concurrent collectors, any result returned from the result
                    supplier, accumulator, or combiner functions must be serially
                    thread-confined.  This enables collection to occur in parallel without
                    the {@code Collector} needing to implement any additional synchronization.
                    The reduction implementation must manage that the input is properly
                    partitioned, that partitions are processed in isolation, and combining
                    happens only after accumulation is complete
    
                    并发多线程
                    For concurrent collectors, an implementation is free to (but not
                    required to) implement reduction concurrently.  A concurrent reduction
                    is one where the accumulator function is called concurrently from
                    multiple threads, using the same concurrently-modifiable result container,
                    rather than keeping the result isolated during accumulation.
                    A concurrent reduction should only be applied if the collector has the
                    {@link Characteristics#UNORDERED} characteristics or if the
                    originating data is unordered
    
                */

## 六、Characteristics对Collectors的性能优化 ##

/*      Characteristics对Collectors的性能优化
                 *
                 *      Collectors also have a set of characteristics, that provide hints that can be used by a
                 *      reduction implementation to provide better performance.
                 *
                 *
                 *      Characteristics indicating properties of a {@code Collector}, which can
                 *      be used to optimize reduction implementations.
                 *
                 *   enum Characteristics {
                 *
                      * Indicates that this collector is <em>concurrent</em>, meaning that
                      * the result container can support the accumulator function being
                      * called concurrently with the same result container from multiple
                      * threads.
                      *
                      * If a {@code CONCURRENT} collector is not also {@code UNORDERED},
                      * then it should only be evaluated concurrently if applied to an
                      * unordered data source.
    
                     CONCURRENT, 多线程处理并发 一定要保证线程安全 使用无序数据源  与UNORDERED联合使用
    
    
                      * Indicates that the collection operation does not commit to preserving
                      * the encounter order of input elements.  (This might be true if the
                      * result container has no intrinsic order, such as a {@link Set}.)
    
                     UNORDERED,  无序集合
    
    
                      * Indicates that the finisher function is the identity function and
                      * can be elided.  If set, it must be the case that an unchecked cast
                      * from A to R will succeed.
    
                     IDENTITY_FINISH  强制类型转换
                 }*/

## 七、Collector接口与 Collectors ##

//     Collectors---> Collector接口简单实现  静态内部类CollectorImpl
            //     为什么要在Collectors类内部定义一个静态内部类CollectorImpl：
            //          Collectors是一个工厂、辅助类  方法的定义是静态的
            //          以类名直接调用方法的方式向developer提供最常见的Collector实现 其实现方式是CollectorImpl
            //          CollectorImpl类 有且仅有在 Collectors类 中使用 所以放在一起

## 八、测试方法： ##

// Accumulate names into a List  将学生姓名累积成ArrayList集合
            List<String> snameList = students.stream()
                    .map(Student::getName).collect(Collectors.toList());
            System.out.println("将学生姓名累积成ArrayList集合：" + snameList.getClass());
            System.out.println(snameList);
            System.out.println("-----------------------------------------\n");
    
            // Accumulate names into a TreeSet 将学生姓名累积成TreeSet集合
            Set<String> snameTree = students.stream()
                    .map(Student::getName).collect(Collectors.toCollection(TreeSet::new));
    
    
    
            System.out.println("将学生姓名累积成TreeSet集合：" + snameTree.getClass());
            System.out.println(snameTree);
            System.out.println("-----------------------------------------\n");
    
            // Convert elements to strings and concatenate them, separated by commas  将学生姓名累积成一个Json串 以逗号分隔
            String joinedStudents = students.stream()
                    .map(Student::toString).collect(Collectors.joining(","));
            System.out.println(" 将学生姓名累积成一个Json串 以逗号分隔：" + joinedStudents);
            System.out.println("-----------------------------------------\n");
    
            // Compute sum of salaries of students  求学生总薪水
            double totalSalary = students.stream()
                    .mapToDouble(Student::getSalary).sum();
            System.out.println("学生总薪水：" + totalSalary);
            System.out.println("-----------------------------------------\n");
    
    
            // the min id of students     打印最小id的学生信息
            System.out.println("最小id的学生信息：");
            students.stream()
                    .min(Comparator.comparingInt(Student::getId))
                    .ifPresent(System.out::println);
            System.out.println("-----------------------------------------\n");
    
    
            // the max id of students     打印最大id的学生信息
            System.out.println("最大id的学生信息：");
            students.stream()
                    .max(Comparator.comparingInt(Student::getId))
                    .ifPresent(System.out::println);
            System.out.println("-----------------------------------------\n");
    
    
            // Compute avg of Age of students   求学生平均年龄
            Double avgAge = students.stream()
                    .collect(Collectors.averagingInt(Student::getAge));
            System.out.println("学生平均年龄：" + avgAge);
            System.out.println("-----------------------------------------\n");
    
    
            // Compute SummaryStatistics of Age of students   打印学生年龄的汇总信息
            IntSummaryStatistics ageSummaryStatistics = students.stream()
                    .collect(Collectors.summarizingInt(Student::getAge));
            System.out.println("学生年龄的汇总信息：" + ageSummaryStatistics);
            System.out.println("-----------------------------------------\n");
    
    
            //  根据性别分组 取id最小的学生
            //  直接使用Collectors.minBy返回的是Optional<Student>
            //  因能确认不为Null 使用Collectors.collectingAndThen-->Optional::get获取
            Map<String, Student> minIdStudent = students.stream().
                    collect(Collectors.groupingBy(Student::getSex, Collectors.collectingAndThen
                            (Collectors.minBy(Comparator.comparingInt(Student::getId)), Optional::get)));
    
            System.out.println(minIdStudent);
            System.out.println("-----------------------------------------\n");
    
        }
    }

## 九、测试结果 ##

.   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
      '  |____| .__|_| |_|_| |_\__, | / / / /
     =========|_|==============|___/=/_/_/_/
     :: Spring Boot ::        (v2.1.2.RELEASE)
    
    2019-02-20 16:11:56.217  INFO 17260 --- [           main] c.j.design.java8.Stream.CollectorDetail  : Starting CollectorDetail on DESKTOP-87RMBG4 with PID 17260 (started by 46250 in E:\IdeaProjects\design)
    2019-02-20 16:11:56.223  INFO 17260 --- [           main] c.j.design.java8.Stream.CollectorDetail  : No active profile set, falling back to default profiles: default
    2019-02-20 16:11:56.699  INFO 17260 --- [           main] c.j.design.java8.Stream.CollectorDetail  : Started CollectorDetail in 0.678 seconds (JVM running for 1.401)
    -----------------------------------------
    
    将学生姓名累积成ArrayList集合：class java.util.ArrayList
    [Kirito, Asuna, Sinon, Yuuki, Alice]
    -----------------------------------------
    
    将学生姓名累积成TreeSet集合：class java.util.TreeSet
    [Alice, Asuna, Kirito, Sinon, Yuuki]
    -----------------------------------------
    
     将学生姓名累积成一个Json串 以逗号分隔：Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8),Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8),Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8),Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8),Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)
    -----------------------------------------
    
    学生总薪水：4.999999995E9
    -----------------------------------------
    
    最小id的学生信息：
    Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)
    -----------------------------------------
    
    最大id的学生信息：
    Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)
    -----------------------------------------
    
    学生平均年龄：16.0
    -----------------------------------------
    
    学生年龄的汇总信息：IntSummaryStatistics{count=5, sum=80, min=14, average=16.000000, max=18}
    -----------------------------------------
    
    {Female=Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8), Male=Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)}
    -----------------------------------------