成人无码视频,亚洲精品久久久久av无码,午夜精品久久久久久毛片,亚洲 中文字幕 日韩 无码

資訊專欄INFORMATION COLUMN

Stream流與Lambda表達(dá)式（二) Stream收集器 Collector接口

or0fun / 3652人閱讀

摘要：一收集器接口陳楊收集器接口匯聚操作的元素類型即流中元素類型匯聚操作的可變累積類型匯聚操作的結(jié)果類型接口一種可變匯聚操作將輸入元素累積到可變結(jié)果容器中在處理完所有輸入元素后可以選擇將累積的結(jié)果轉(zhuǎn)換為最終表示可選操作歸約操作

一、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 students;

    @Before
    public void init() {
        students=new Students().init();
    }

    @Test
    public void testCollectorDetail() {


        //     Collect 收集器 ---- Collector接口

        //     T-->匯聚操作的元素類型 即流中元素類型
        //     A-->匯聚操作的可變累積類型
        //     R-->匯聚操作的結(jié)果類型
        //     public interface Collector

        //     Collector接口   一種可變匯聚操作
        //                    將輸入元素累積到可變結(jié)果容器中
        //                    在處理完所有輸入元素后 可以選擇將累積的結(jié)果轉(zhuǎn)換為最終表示（可選操作）
        //                    歸約操作支持串行與并行
        //     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 匯聚實(shí)現(xiàn)  實(shí)際上是一個(gè)Collector工廠
        //     The class {@link Collectors}  provides implementations of many common mutable reductions.
二、Collector 接口組成 
    //     Collector 由以下4個(gè)函數(shù)協(xié)同累積到容器 可選的執(zhí)行最終轉(zhuǎn)換
    //               supplier           創(chuàng)建一個(gè)新的結(jié)果容器
    //               accumulator累加器   將新數(shù)據(jù)元素合并到結(jié)果容器中
    //               combiner           合并結(jié)果容器  處理線程并發(fā)
    //               finisher           對(duì)容器執(zhí)行可選的最終轉(zhuǎn)換
    //
    //     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 combiner();
         */

       /*     supplier創(chuàng)建單個(gè)結(jié)果容器-->accumulator調(diào)用累積功能-->partition結(jié)果--分區(qū)容器-->combiner合并分區(qū)容器

              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 約束 
/*
       確保串行與并行結(jié)果的一致性，滿足約束： identity  associativity
       To ensure that sequential and parallel executions produce equivalent
       results, the collector functions must satisfy an identity and an associativity constraints.
 */

/*     identity 約束：
       對(duì)于任何部分累積的結(jié)果， 將其與空結(jié)果容器組合必須生成等效的結(jié)果
       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 約束：
       串行計(jì)算與并行拆分計(jì)算必須產(chǎn)生同等的結(jié)果

       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 匯聚 的實(shí)現(xiàn)方式 
        //      reduction 匯聚 的實(shí)現(xiàn)方式
        //      list.stream().reduce()                        對(duì)象不可變
        //      list.stream().collect(Collectors.reducing())  對(duì)象可變
        //      單線程可以實(shí)現(xiàn)結(jié)果一致 但在多線程中就會(huì)出現(xiàn)錯(cuò)誤

        /*

                 Libraries that implement reduction based on {@code Collector}, such as
                 {@link Stream#collect(Collector)}, must adhere to the following constraints:


                 傳遞給accumulator的第一個(gè)參數(shù)，傳遞給combiner的二個(gè)參數(shù)，傳遞給finisher的參數(shù)
                 必須是函數(shù)（supplier accumulator combiner）上一次調(diào)用結(jié)果
                 理解： 參數(shù)類型A
                 Supplier supplier();
                 BiConsumer accumulator();
                 BinaryOperator combiner();
                 Function 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的實(shí)現(xiàn)結(jié)果-->
                傳遞給下一次supplier accumulator combiner操作
                或返還給匯聚操作的調(diào)用方
                而不進(jìn)行其他操作
                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


                一個(gè)結(jié)果傳遞給combiner finisher而相同的對(duì)象沒有從此函數(shù)中返回 這個(gè)結(jié)果不會(huì)再被使用
                這個(gè)傳入結(jié)果是被消費(fèi)了 生成了新的對(duì)象
                 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


                一旦結(jié)果傳遞給combiner finisher 則不再會(huì)傳遞給accumulator
                說(shuō)明流中元素已經(jīng)傳遞完全  accumulator任務(wù)已執(zhí)行完畢
                Once a result is passed to the combiner or finisher function, it
                is never passed to the accumulator function again

                非并發(fā)單線程
                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

                并發(fā)多線程
                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對(duì)Collectors的性能優(yōu)化 
            /*      Characteristics對(duì)Collectors的性能優(yōu)化
             *
             *      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 concurrent, 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, 多線程處理并發(fā) 一定要保證線程安全 使用無(wú)序數(shù)據(jù)源  與UNORDERED聯(lián)合使用


                  * 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,  無(wú)序集合


                  * 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  強(qiáng)制類型轉(zhuǎn)換
             }*/
七、Collector接口與 Collectors 
        //     Collectors---> Collector接口簡(jiǎn)單實(shí)現(xiàn)  靜態(tài)內(nèi)部類CollectorImpl
        //     為什么要在Collectors類內(nèi)部定義一個(gè)靜態(tài)內(nèi)部類CollectorImpl：
        //          Collectors是一個(gè)工廠、輔助類  方法的定義是靜態(tài)的
        //          以類名直接調(diào)用方法的方式向developer提供最常見的Collector實(shí)現(xiàn) 其實(shí)現(xiàn)方式是CollectorImpl
        //          CollectorImpl類 有且僅有在 Collectors類 中使用 所以放在一起
八、測(cè)試方法： 
        // Accumulate names into a List  將學(xué)生姓名累積成ArrayList集合
        List snameList = students.stream()
                .map(Student::getName).collect(Collectors.toList());
        System.out.println("將學(xué)生姓名累積成ArrayList集合：" + snameList.getClass());
        System.out.println(snameList);
        System.out.println("-----------------------------------------
");

        // Accumulate names into a TreeSet 將學(xué)生姓名累積成TreeSet集合
        Set snameTree = students.stream()
                .map(Student::getName).collect(Collectors.toCollection(TreeSet::new));



        System.out.println("將學(xué)生姓名累積成TreeSet集合：" + snameTree.getClass());
        System.out.println(snameTree);
        System.out.println("-----------------------------------------
");

        // Convert elements to strings and concatenate them, separated by commas  將學(xué)生姓名累積成一個(gè)Json串 以逗號(hào)分隔
        String joinedStudents = students.stream()
                .map(Student::toString).collect(Collectors.joining(","));
        System.out.println(" 將學(xué)生姓名累積成一個(gè)Json串 以逗號(hào)分隔：" + joinedStudents);
        System.out.println("-----------------------------------------
");

        // Compute sum of salaries of students  求學(xué)生總薪水
        double totalSalary = students.stream()
                .mapToDouble(Student::getSalary).sum();
        System.out.println("學(xué)生總薪水：" + totalSalary);
        System.out.println("-----------------------------------------
");


        // the min id of students     打印最小id的學(xué)生信息
        System.out.println("最小id的學(xué)生信息：");
        students.stream()
                .min(Comparator.comparingInt(Student::getId))
                .ifPresent(System.out::println);
        System.out.println("-----------------------------------------
");


        // the max id of students     打印最大id的學(xué)生信息
        System.out.println("最大id的學(xué)生信息：");
        students.stream()
                .max(Comparator.comparingInt(Student::getId))
                .ifPresent(System.out::println);
        System.out.println("-----------------------------------------
");


        // Compute avg of Age of students   求學(xué)生平均年齡
        Double avgAge = students.stream()
                .collect(Collectors.averagingInt(Student::getAge));
        System.out.println("學(xué)生平均年齡：" + avgAge);
        System.out.println("-----------------------------------------
");


        // Compute SummaryStatistics of Age of students   打印學(xué)生年齡的匯總信息
        IntSummaryStatistics ageSummaryStatistics = students.stream()
                .collect(Collectors.summarizingInt(Student::getAge));
        System.out.println("學(xué)生年齡的匯總信息：" + ageSummaryStatistics);
        System.out.println("-----------------------------------------
");


        //  根據(jù)性別分組 取id最小的學(xué)生
        //  直接使用Collectors.minBy返回的是Optional
        //  因能確認(rèn)不為Null 使用Collectors.collectingAndThen-->Optional::get獲取
        Map 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("-----------------------------------------
");

    }
}
九、測(cè)試結(jié)果 
  .   ____          _            __ _ _
 / / ___"_ __ _ _(_)_ __  __ _    
( ( )\___ | "_ | "_| | "_ / _` |    
 /  ___)| |_)| | | | | || (_| |  ) ) ) )
  "  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: 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:IdeaProjectsdesign)
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)
-----------------------------------------

將學(xué)生姓名累積成ArrayList集合：class java.util.ArrayList
[Kirito, Asuna, Sinon, Yuuki, Alice]
-----------------------------------------

將學(xué)生姓名累積成TreeSet集合：class java.util.TreeSet
[Alice, Asuna, Kirito, Sinon, Yuuki]
-----------------------------------------

 將學(xué)生姓名累積成一個(gè)Json串 以逗號(hào)分隔：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)
-----------------------------------------

學(xué)生總薪水：4.999999995E9
-----------------------------------------

最小id的學(xué)生信息：
Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)
-----------------------------------------

最大id的學(xué)生信息：
Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)
-----------------------------------------

學(xué)生平均年齡：16.0
-----------------------------------------

學(xué)生年齡的匯總信息：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)}
-----------------------------------------

文章版權(quán)歸作者所有，未經(jīng)允許請(qǐng)勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請(qǐng)注明本文地址：http://m.hztianpu.com/yun/73352.html

相關(guān)文章

  • Stream流與Lambda表達(dá)式（四） 自定義收集器

    摘要：一自定義收集器陳楊將集合轉(zhuǎn)換為集合存放相同元素二自定義收集器陳楊將學(xué)生對(duì)象按照存放從中間容器數(shù)據(jù)類型轉(zhuǎn)換為結(jié)果類型數(shù)據(jù)類型一致若不一致拋出類型轉(zhuǎn)換異常對(duì)中間容器數(shù)據(jù)結(jié)果類型進(jìn)行強(qiáng)制類型轉(zhuǎn)換多個(gè)線程同時(shí)操作同一個(gè)容器并行多線 一、自定義SetCustomCollector收集器 package com.java.design.Stream.CustomCollector; impor...

    wind5o 評(píng)論0 收藏0

  • Stream流與Lambda表達(dá)式（三） 靜態(tài)工廠類Collectors

    摘要：陳楊一靜態(tài)工廠類實(shí)現(xiàn)方式一靜態(tài)工廠類實(shí)現(xiàn)方式靜態(tài)工廠類最終由實(shí)現(xiàn)通過(guò)實(shí)現(xiàn)通過(guò)實(shí)現(xiàn)底層由實(shí)現(xiàn)是的一種具化表現(xiàn)形式使用拼接字符串二靜態(tài)工廠類常用收集器二靜態(tài)工廠類常用收集器返回一個(gè)不可修改的按照相遇的順序返回一個(gè)不可修改的無(wú)序返回 /** * @author 陳楊 */ @SpringBootTest @RunWith(SpringRunner.class) public class...

    phodal 評(píng)論0 收藏0

  • Java８新特性總覽

    摘要：新特性總覽標(biāo)簽本文主要介紹的新特性，包括表達(dá)式方法引用流默認(rèn)方法組合式異步編程新的時(shí)間，等等各個(gè)方面。還有對(duì)應(yīng)的和類型的函數(shù)連接字符串廣義的歸約匯總起始值，映射方法，二元結(jié)合二元結(jié)合。使用并行流時(shí)要注意避免共享可變狀態(tài)。 Java８新特性總覽 標(biāo)簽： java [TOC] 本文主要介紹 Java 8 的新特性，包括 Lambda 表達(dá)式、方法引用、流(Stream API)、默認(rèn)方...

    mayaohua 評(píng)論0 收藏0

  • Stream流與Lambda表達(dá)式（一） 雜談

    摘要：一流轉(zhuǎn)換為數(shù)組集合陳楊將流轉(zhuǎn)換為數(shù)組將流轉(zhuǎn)換為數(shù)組將流轉(zhuǎn)換為集合將流轉(zhuǎn)換為集合解析 一、流 轉(zhuǎn)換為數(shù)組、集合 package com.java.design.java8.Stream; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context...

    Harpsichord1207 評(píng)論0 收藏0

  • 《Java8實(shí)戰(zhàn)》-第六章讀書筆記（用流收集數(shù)據(jù)-01）

    摘要：收集器用作高級(jí)歸約剛剛的結(jié)論又引出了優(yōu)秀的函數(shù)式設(shè)計(jì)的另一個(gè)好處更易復(fù)合和重用。更具體地說(shuō)，對(duì)流調(diào)用方法將對(duì)流中的元素觸發(fā)一個(gè)歸約操作由來(lái)參數(shù)化。另一個(gè)常見的返回單個(gè)值的歸約操作是對(duì)流中對(duì)象的一個(gè)數(shù)值字段求和。 用流收集數(shù)據(jù) 我們?cè)谇耙徽轮袑W(xué)到，流可以用類似于數(shù)據(jù)庫(kù)的操作幫助你處理集合。你可以把Java 8的流看作花哨又懶惰的數(shù)據(jù)集迭代器。它們支持兩種類型的操作：中間操作（如 filt...

    EscapedDog 評(píng)論0 收藏0

發(fā)表評(píng)論

0條評(píng)論

or0fun

男|高級(jí)講師

TA的文章

閱讀更多
最新活動(dòng)
閱讀需要支付1元查看
<