jdk1.8 -- Collectors 的使用

package com.collector;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.IntSummaryStatistics;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.TreeMap;

import java.util.function.Function;

import java.util.stream.Collector;

import java.util.stream.Collectors;

import com.zpb.video_06.Dish;

import com.zpb.video_06.Dish.Type;

/**

 * @des        Collector API的使用

 *                 三大功能：聚合    分组     统计

 * @author  zhao

 * @date    2019年9月22日下午11:53:54

 *

 */

public class CollectorsAPI {

    public static final List<Dish> menu =  Arrays.asList(

            new Dish("pork", false, 800, Dish.Type.MEAT),

            new Dish("beef", false, 700, Dish.Type.MEAT),

            new Dish("chicken", false, 400, Dish.Type.MEAT),

            new Dish("french fries", true, 530, Dish.Type.OTHER),

            new Dish("rice", true, 350, Dish.Type.OTHER),

            new Dish("season fruit", true, 120, Dish.Type.OTHER),

            new Dish("pizza", true, 550, Dish.Type.OTHER),

            new Dish("prawns", false, 300, Dish.Type.FISH),

            new Dish("salmon", false, 450, Dish.Type.FISH));

    public static void main(String[] args) {

        //1.求平均值

        testAveragingDouble();

        testaveragingInt();

        testAveragingLong();

        testCollectingAndThen();

        //2.统计

        testCounting();

        testGroupByFunction();

        testGroupByFunctionAndCollectors();

        testGroupByFunctionAndAndCollectors();

        testSummarizingInt();

    }

    private static void testSummarizingInt() {

        IntSummaryStatistics intSummary = menu.stream().collect(Collectors.summarizingInt(Dish::getCalories));

        Optional.ofNullable(intSummary).ifPresent(System.out::println);

    }

    private static void testGroupByFunctionAndAndCollectors() {

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

        Map<Type, Double> map = menu.stream().collect(Collectors.groupingBy(Dish::getType,Collectors.averagingDouble(Dish::getCalories)));

        Optional.ofNullable(map.getClass()).ifPresent(System.out::println);        //hashmap

        //我们得到的是hashMap， 下面把它改成treeMap

        TreeMap<Type, Double> map2 = menu.stream().collect(Collectors.groupingBy(Dish::getType, TreeMap::new, Collectors.averagingDouble(Dish::getCalories)));

        Optional.ofNullable(map2.getClass()).ifPresent(System.out::println);

    }

    private static void testGroupByFunctionAndCollectors() {

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

        Optional.ofNullable(menu.stream().collect(Collectors.groupingBy(Dish::getType, Collectors.counting())))

        .ifPresent(System.out::println);

        //每个分类下卡路里平均值

        Optional.ofNullable(

        menu.stream().collect(Collectors.groupingBy(Dish::getType, Collectors.averagingDouble(Dish::getCalories))))

        .ifPresent(System.out::println);

    }

    private static void testGroupByFunction() {

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

        Optional.ofNullable(menu.stream().collect(Collectors.groupingBy(Dish::getType)))

                .ifPresent(System.out::println);

    }

    private static void testCounting() {

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

        Optional.ofNullable(menu.stream().collect(Collectors.counting())).ifPresent(System.out::println);

    }

    private static void testAveragingDouble() {

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

        Optional.ofNullable(menu.stream().collect(Collectors.averagingDouble(Dish::getCalories)))

        .ifPresent(System.out::println);

    }

    private static void testaveragingInt() {

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

        Optional.ofNullable(menu.stream().collect(Collectors.averagingInt(Dish::getCalories)))

        .ifPresent(System.out::println);

    }

    private static void testAveragingLong() {

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

        Optional.ofNullable(menu.stream().collect(Collectors.averagingLong(Dish::getCalories)))

        .ifPresent(System.out::println);

    }

    private static void testCollectingAndThen() {

        /**

         * collectingAndThen(Collector<T,A,R> downstream,Function<R,RR> finisher)

         *   第1个参数是： Collector,也就是通过Collectors拿到的集合

         *   第2个参数是：Function,也就是传入2个参数，R RR,返回的是RR

         *  该方法最主要是要用好参数是怎么传入的

         */

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

        //1.获取到平均值，然后变成字符串输出

        Optional.ofNullable(menu.stream().

                collect(Collectors.collectingAndThen(Collectors.averagingLong(Dish::getCalories), a->"calories avg is "+a)))

                .ifPresent(System.out::println);

        //2.得到指定集合，不能被别人修改

        List<Dish> collect = menu.stream().filter(m->m.getType().equals(Type.MEAT))

            .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));

        Optional.ofNullable(collect).orElseGet(ArrayList::new).forEach(System.out::println);

    }

}

package com.collector;

import java.awt.Menu;

import java.util.Comparator;

import java.util.List;

import java.util.Optional;

import java.util.concurrent.ConcurrentSkipListMap;

import java.util.stream.Collectors;

import com.collector.CollectorsAPI1;

import com.zpb.video_06.Dish;

import com.zpb.video_06.Dish.Type;

/**

 * @des

 * @author  zhao

 * @date    2019年9月24日上午12:13:00

 *

 */

public class CollectorsAPI2 {

    static List<Dish> menu = CollectorsAPI1.menu;

    public final static void main(String[] args) {

        testGroupingByConcurrent();

        testGroupingByConcurrentAndCollectors();

        testGroupingByConcurrentAndSkipAndCollectors();

        testJoining();

        testJoiningAndPrefixAndSuffix();

        testMapping();

        testMaxBy();

        testMinBy();

    }

    //maxBy(Comparator<? super T> comparator) 按Comparator比较器规则，选出最大值

    public static void testMaxBy() {

        System.out.println(">>>>>>>>>>>>>>> testMaxBy  >>>>>>>>>>>>>>>");

        menu.stream().collect(Collectors.maxBy(Comparator.comparing(Dish::getCalories)))

            .ifPresent(System.out::println);

    }

    //maxBy(Comparator<? super T> comparator) 按Comparator比较器规则，选出最小值

    public static void testMinBy() {

        System.out.println(">>>>>>>>>>>>>>> testMaxBy  >>>>>>>>>>>>>>>");

        menu.stream().collect(Collectors.minBy(Comparator.comparing(Dish::getCalories)))

            .ifPresent(System.out::println);

    }

    public static void testMapping() {

        System.out.println(">>>>>>>>>>>>>>> testMapping  >>>>>>>>>>>>>>>");

        /**

         *  mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream) {

         *  第1个参数得到的结果作为第2个参数操作的源数据

         */

        Optional.ofNullable(menu.stream().collect(Collectors.mapping(Dish::getName, Collectors.joining(","))))

                .ifPresent(System.out::println);

    }

    //连接操作

    public static void testJoining() {

        System.out.println(">>>>>>>>>>>>>>> testJoining()  >>>>>>>>>>>>>>>");

        Optional.ofNullable(menu.stream().map(Dish::getName).collect(Collectors.joining("#")))

                .ifPresent(System.out::println);

    }

    public static void testJoiningAndPrefixAndSuffix() {

        System.out.println(">>>>>>>>>>>>>>> testJoiningAndPrefixAndSuffix()  >>>>>>>>>>>>>>>");

        Optional.ofNullable(menu.stream().map(Dish::getName).collect(Collectors.joining(",","Name[","]")))

        .ifPresent(System.out::println);

    }

    public static void testGroupingByConcurrentAndSkipAndCollectors() {

        System.out.println(">>>>>>>>>>>>>>> testGroupingByConcurrentAndSkipAndCollectors()  >>>>>>>>>>>>>>>");

        ConcurrentSkipListMap<Type, Double> skipListMap =

            menu.stream().collect(Collectors.groupingBy(Dish::getType, ConcurrentSkipListMap::new,Collectors.averagingDouble(Dish::getCalories)));

        Optional.ofNullable(skipListMap.getClass()).ifPresent(System.out::println);

        Optional.ofNullable(skipListMap).ifPresent(System.out::println);

    }

    public static void testGroupingByConcurrentAndCollectors() {

        System.out.println(">>>>>>>>>>>>>>> testGroupingByConcurrentAndCollectors >>>>>>>>>>>>>>>");

        Optional.ofNullable(menu.stream().collect(Collectors.groupingBy(Dish::getType, Collectors.averagingDouble(Dish::getCalories))))

                .ifPresent(System.out::println);

    }

    //1.按类型分类，返回类型是：CurrentMap

    public static void testGroupingByConcurrent() {

        System.out.println(">>>>>>>>>>>>>>> testGroupingByConcurrent >>>>>>>>>>>>>>>");

        Optional.ofNullable(menu.stream().collect(Collectors.groupingByConcurrent(Dish::getType)))

                .ifPresent(System.out::println);

    }

}

package com.collector;

/**

 * @des

 * @author  zhao

 * @date    2019年9月25日下午8:21:52

 *

 */

import static com.collector.CollectorsAPI1.menu;

import java.util.Comparator;

import java.util.DoubleSummaryStatistics;

import java.util.IntSummaryStatistics;

import java.util.List;

import java.util.LongSummaryStatistics;

import java.util.Map;

import java.util.Optional;

import java.util.function.BinaryOperator;

import java.util.stream.Collectors;

import com.zpb.video_06.Dish;

public class CollectorsAPI3 {

    public static void main(String[] args) {

        // partitioningBy(Predicate<? super T> predicate) 通过条件判断来分组

        // 注意返回值是map类型的，当key为true时，表示是value中是符合判断条件的list集合，反之则不是

        Map<Boolean, List<Dish>> collect = menu.stream().collect(Collectors.partitioningBy(Dish::isVegetarian));

        Optional.ofNullable(collect).ifPresent(System.out::println);

        // partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)

        // 通过判断条件得到的集合，交给下一个collector进行处理

        Map<Boolean, Double> collect2 = menu.stream()

                .collect(Collectors.partitioningBy(Dish::isVegetarian, Collectors.averagingDouble(Dish::getCalories)));

        Optional.ofNullable(collect2).ifPresent(System.out::println);

        // reducing(BinaryOperator<T> op) 聚合操作(用的是BinaryOperator本身的方法)

        Optional<Dish> collect3 = menu.stream()

                .collect(Collectors.reducing(BinaryOperator.maxBy(Comparator.comparing(Dish::getCalories))));

        collect3.ifPresent(System.out::println);

        // reducing(T identity, BinaryOperator<T> op) T: 返回值类型值, op: 二元操作(怎么运算,用的是BinaryOperator父类BiFunction的方法)

        Integer collect4 = menu.stream().map(Dish::getCalories).collect(Collectors.reducing(0, (d1, d2) -> d1 + d2));

        Optional.ofNullable(collect4).ifPresent(System.out::println);

        //reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)

        //第1个参数：定义类型，

        //第二个参数：定义了第2个参数必须是第1个参数的类型歌者是其子类

        //第三个参数：op: 二元操作(怎么运算,用的是BinaryOperator父类BiFunction的方法)

        menu.stream().collect(Collectors.reducing(0, Dish::getCalories,(d1,d2) -> d1 + d2));

        //summarizingDouble(ToDoubleFunction<? super T> mapper) 求集合元素的平均结果

        DoubleSummaryStatistics collect5 = menu.stream().collect(Collectors.summarizingDouble(Dish::getCalories));    //这里发生了隐式转换

        Optional.ofNullable(collect5).ifPresent(System.out::println);

        //summarizingInt(ToIntFunction<? super T> mapper)

        IntSummaryStatistics collect6 = menu.stream().collect(Collectors.summarizingInt(Dish::getCalories));

        Optional.ofNullable(collect5).ifPresent(System.out::println);

        //Collectors.summarizingLong

        LongSummaryStatistics collect7 = menu.stream().collect(Collectors.summarizingLong(Dish::getCalories));

        Optional.ofNullable(collect7).ifPresent(System.out::println);

        //summingInt(ToIntFunction<? super T> mapper) 求某个元素的合

        Integer collect8 = menu.stream().collect(Collectors.summingInt(Dish::getCalories));

        Double collect9 = menu.stream().collect(Collectors.summingDouble(Dish::getCalories));

        Long collect10 = menu.stream().collect(Collectors.summingLong(Dish::getCalories));

        Optional.ofNullable(collect8).ifPresent(System.out::println);

        Optional.ofNullable(collect9).ifPresent(System.out::println);

        Optional.ofNullable(collect10).ifPresent(System.out::println);

    }

}

package com.collector;

/**

 * @des

 * @author  zhao

 * @date    2019年9月25日下午9:36:49

 *

 */

import static com.collector.CollectorsAPI1.menu;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.concurrent.ConcurrentMap;

import java.util.concurrent.ConcurrentSkipListMap;

import java.util.function.BinaryOperator;

import java.util.stream.Collectors;

import com.zpb.video_06.Dish;

import com.zpb.video_06.Dish.Type;

public class CollectorsAPI4 {

    public static void main(String[] args) {

        // toCollection(Supplier<C> collectionFactory)

        // 参数：只要是Collection的子类即可

        ArrayList<Dish> collect = menu.stream().collect(Collectors.toCollection(ArrayList::new));

        LinkedHashSet<Dish> collect2 = menu.stream().collect(Collectors.toCollection(LinkedHashSet::new));

        // toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super

        // T,? extends U> valueMapper)

        ConcurrentMap<String, Integer> collect3 = menu.stream()

                .collect(Collectors.toConcurrentMap(Dish::getName, Dish::getCalories));

        Optional.ofNullable(collect3).ifPresent(System.out::println);

        System.out.println(">>>>>>>>>>>>>>>>>> 1");

        // toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super

        // T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)

        // 第1个参数：通过Function拿到key

        // 第2个参数：通过Function拿到value

        // 第3个参数：将前面的value进行二次元操作

        ConcurrentMap<String, Integer> collect4 = menu.stream().filter(d -> d.getCalories() > 500)

                .collect(Collectors.toConcurrentMap(Dish::getName, Dish::getCalories, (d1, d2) -> d1 + d2));

        Optional.ofNullable(collect4).ifPresent(System.out::println);

        Optional.ofNullable(collect4.getClass()).ifPresent(System.out::println);

        System.out.println(">>>>>>>>>>>>>>>>>> 2");

        // 对同一类型的值进行++操作

        menu.stream().collect(Collectors.toConcurrentMap(Dish::getType, v -> 1L, (a, b) -> a + b));

        // toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super

        // T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M>

        // mapSupplier)

        // 由上面可知得到的类型是concurrentHashMap类型,第4个参数就是要转换成哪种map类型

        // 第1个参数：通过Function拿到key

        // 第2个参数：通过Function拿到value

        // 第3个参数：将前面的value进行二次元操作

        // 第4个参数：通过Supplier转换成其它类型

        ConcurrentSkipListMap<Type, Long> collect5 = menu.stream().filter(d -> d.getCalories() > 500).collect(

                Collectors.toConcurrentMap(Dish::getType, v -> 1L, (a, b) -> a + b, ConcurrentSkipListMap::new));

        // toList()

        List<Dish> collect6 = menu.stream().collect(Collectors.toList());

        Optional.ofNullable(collect6).ifPresent(System.out::println);

        // toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends

        // U> valueMapper)

        Map<String, Long> collect7 = menu.stream().collect(Collectors.toMap(Dish::getName, V -> 1L));

        // toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends  U> valueMapper, BinaryOperator<U> mergeFunction)

        Map<String, Long> collect8 = menu.stream().collect(Collectors.toMap(Dish::getName, v -> 1L, (a, b) -> a + b));

        // toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper,

        // BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)

        menu.stream().collect(Collectors.toMap(Dish::getType, v -> 1L, (a, b) -> a + b,  ConcurrentSkipListMap::new));

        System.out.println(">>>>>>>>>>>>>>>>>> 6");

        menu.stream().collect(Collectors.collectingAndThen(Collectors.toMap(Dish::getName, Dish::getCalories), Collections::synchronizedMap));

        Set<Dish> collect9 = menu.stream().collect(Collectors.toSet());

        Optional.ofNullable(collect9).ifPresent(System.out::println);

    }

}

jdk1.8 -- Collectors 的使用的更多相关文章

JDK1.8新特性——Collector接口和Collectors工具类
JDK1.8新特性——Collector接口和Collectors工具类摘要:本文主要学习了在Java1.8中新增的Collector接口和Collectors工具类,以及使用它们在处理集合时的改进 ...
JDK1.8新特性（二）：Collectors收集器类
一. 什么是Collectors? Java 8 API添加了一个新的抽象称为流Stream,我们借助Stream API可以很方便的操作流对象. Stream中有两个方法collect和collec ...
【JDK1.8】JDK1.8集合源码阅读——总章
一.前言今天开始阅读jdk1.8的集合部分,平时在写项目的时候,用到的最多的部分可能就是Java的集合框架,通过阅读集合框架源码,了解其内部的数据结构实现,能够深入理解各个集合的性能特性,并且能够帮 ...
Java进阶篇之十五 ----- JDK1.8的Lambda、Stream和日期的使用详解(很详细)
前言本篇主要讲述是Java中JDK1.8的一些新语法特性使用,主要是Lambda.Stream和LocalDate日期的一些使用讲解. Lambda Lambda介绍 Lambda 表达式(lamb ...
【新特性】JDK1.8
一.简介毫无疑问,Java 8是Java自Java 5(发布于2004年)之后的最重要的版本.这个版本包含语言.编译器.库.工具和JVM等方面的十多个新特性.在本文中我们将学习这些新特性,并用实际的 ...
jdk1.8
Jdk1.8新特性毫无疑问,Java 8是Java自Java 5(发布于2004年)之后的最重要的版本.这个版本包含语言.编译器.库.工具和JVM等方面的十多个新特性.在本文中我们将学习这些新特性, ...
jdk1.8新特性应用之Collection
之前说了jdk1.8几个新特性,现在看下实战怎么玩,直接看代码: public List<MSG_ConMediaInfo> getConMediaInfoList(String live ...
JDK1.8源码泛读之Arrays
jdk1.8包含的常用集合工具类,一般包括两个: 数组工具类:`java.util.Arrays ` 结合工具类:`java.util.Collections` 今天就结合源码对`java.util. ...
java使用lambda表达式对List集合进行操作(JDK1.8)
1. 使用lambda表达式对List集合进行操作(JDK1.) List<TreeDto> collect = list.stream().filter(item -> item. ...

随机推荐

010_Linux驱动之_DECLARE_WAIT_QUEUE_HEAD函数
1. 功能:创建以个等待队列头 2. 函数原型 #define DECLARE_WAIT_QUEUE_HEAD (name) / wait ...
sql server 存储过程和视图的区别
视图要把视图看做是一张表,包含了一张表的部分数据或者多个表的综合数据,视图的使用和普通表一样: 视图建立并存储在服务器,有效减少网络数据流量,提高安全性: 视图中不存放数据,数据依然存放在视图引用的 ...
解决eslint与webstorm关于script标签的缩进问题
解决eslint与webstorm关于script标签的缩进问题 2018年12月29日 23:16:29 tozeroblog 阅读数 752 问题重现在vue-cli中,使用eslint时会对 ...
leetcode解题报告（8）：Remove Element
描述 Given an array and a value, remove all instances of that value in place and return the new length ...
异步时钟FIFO（一）
FIFO一般用于通过两个不同时钟域的数据传输.一个水池有进和出两个通道,由于进出口水流不一致所以需要水池加以缓冲.堆栈也是相当于水池的作用.如果输入端不是连续的数据流,可以通过堆栈来调节使数据以稳定的 ...
Applications （ZOJ 3705）
题解:就是题目有点小长而已,可能会不想读题,但是题意蛮好理解的,就是根据条件模拟,计算pts.(送给队友zm. qsh,你们不适合训练了.) #include <iostream> #in ...
codeforces722E
CF722E Research Rover Unfortunately, the formal description of the task turned out to be too long, s ...
菜单栏伸缩（附jquery-1.12.1.js）
Css: <style type="text/css"> .leftMenu { min-width:220px; width:268px; margin:40px a ...
百度地图API根据地名获取经纬度
运用了Geocoding API,它包括地址解析和逆地址解析功能. 地址解析是指,由详细到街道的结构化地址得到百度经纬度信息,且支持名胜古迹.标志性建筑名称直接解析返回百度经纬度.例如:“北京市海淀区 ...
Python进行Redis数据迁移
Python进行Redis数据迁移由于开发时的误操作,导致redis数据损坏,所以需要进行redis的数据迁移,网上大佬的教程基本都是需要下载附加工具,亦或是需要一些复杂的操作,个人觉得麻烦还不如写 ...

jdk1.8 -- Collectors 的使用

jdk1.8 -- Collectors 的使用的更多相关文章

随机推荐

热门专题