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 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 map = menu.stream().collect(Collectors.groupingBy(Dish::getType,Collectors.averagingDouble(Dish::getCalories)));
        Optional.ofNullable(map.getClass()).ifPresent(System.out::println);        //hashmap 
        //我们得到的是hashMap， 下面把它改成treeMap
        TreeMap 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 downstream,Function 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 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 menu = CollectorsAPI1.menu;
    
    public final static void main(String[] args) {
        
        testGroupingByConcurrent();
        testGroupingByConcurrentAndCollectors();
        testGroupingByConcurrentAndSkipAndCollectors();
        testJoining();
        testJoiningAndPrefixAndSuffix();
        testMapping();
        testMaxBy();
        testMinBy();
    }
    
    //maxBy(Comparator 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 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 mapper, Collector 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 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 predicate) 通过条件判断来分组
        // 注意返回值是map类型的，当key为true时，表示是value中是符合判断条件的list集合，反之则不是
        Map> collect = menu.stream().collect(Collectors.partitioningBy(Dish::isVegetarian));
        Optional.ofNullable(collect).ifPresent(System.out::println);

        // partitioningBy(Predicate predicate, Collector downstream)
        // 通过判断条件得到的集合，交给下一个collector进行处理
        Map collect2 = menu.stream()
                .collect(Collectors.partitioningBy(Dish::isVegetarian, Collectors.averagingDouble(Dish::getCalories)));
        Optional.ofNullable(collect2).ifPresent(System.out::println);

        // reducing(BinaryOperator op) 聚合操作(用的是BinaryOperator本身的方法)
        Optional collect3 = menu.stream()
                .collect(Collectors.reducing(BinaryOperator.maxBy(Comparator.comparing(Dish::getCalories))));
        collect3.ifPresent(System.out::println);

        // reducing(T identity, BinaryOperator 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 mapper, BinaryOperator op) 
        //第1个参数：定义类型，
        //第二个参数：定义了第2个参数必须是第1个参数的类型歌者是其子类
        //第三个参数：op: 二元操作(怎么运算,用的是BinaryOperator父类BiFunction的方法)
        menu.stream().collect(Collectors.reducing(0, Dish::getCalories,(d1,d2) -> d1 + d2));
        
        //summarizingDouble(ToDoubleFunction mapper) 求集合元素的平均结果
        DoubleSummaryStatistics collect5 = menu.stream().collect(Collectors.summarizingDouble(Dish::getCalories));    //这里发生了隐式转换
        Optional.ofNullable(collect5).ifPresent(System.out::println);
        
        //summarizingInt(ToIntFunction 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 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 collectionFactory)
        // 参数：只要是Collection的子类即可
        ArrayList collect = menu.stream().collect(Collectors.toCollection(ArrayList::new));
        LinkedHashSet collect2 = menu.stream().collect(Collectors.toCollection(LinkedHashSet::new));

        // toConcurrentMap(Function keyMapper, Function// T,? extends U> valueMapper)
        ConcurrentMap collect3 = menu.stream()
                .collect(Collectors.toConcurrentMap(Dish::getName, Dish::getCalories));
        Optional.ofNullable(collect3).ifPresent(System.out::println);
        System.out.println(">>>>>>>>>>>>>>>>>> 1");
        // toConcurrentMap(Function keyMapper, Function// T,? extends U> valueMapper, BinaryOperator mergeFunction)
        // 第1个参数：通过Function拿到key
        // 第2个参数：通过Function拿到value
        // 第3个参数：将前面的value进行二次元操作
        ConcurrentMap 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 keyMapper, Function// T,? extends U> valueMapper, BinaryOperator mergeFunction, Supplier
        // mapSupplier)
        // 由上面可知得到的类型是concurrentHashMap类型,第4个参数就是要转换成哪种map类型
        // 第1个参数：通过Function拿到key
        // 第2个参数：通过Function拿到value
        // 第3个参数：将前面的value进行二次元操作
        // 第4个参数：通过Supplier转换成其它类型
        ConcurrentSkipListMap collect5 = menu.stream().filter(d -> d.getCalories() > 500).collect(
                Collectors.toConcurrentMap(Dish::getType, v -> 1L, (a, b) -> a + b, ConcurrentSkipListMap::new));

        // toList()
        List collect6 = menu.stream().collect(Collectors.toList());
        Optional.ofNullable(collect6).ifPresent(System.out::println);

        // toMap(Function keyMapper, Function// U> valueMapper)
        Map collect7 = menu.stream().collect(Collectors.toMap(Dish::getName, V -> 1L));

        // toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction)
        Map collect8 = menu.stream().collect(Collectors.toMap(Dish::getName, v -> 1L, (a, b) -> a + b));

        // toMap(Function keyMapper, Function valueMapper,
        // BinaryOperator mergeFunction, Supplier 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 collect9 = menu.stream().collect(Collectors.toSet());
        Optional.ofNullable(collect9).ifPresent(System.out::println);
    }
}

 

转载于:https://www.cnblogs.com/MrRightZhao/p/11576067.html