Jdk1.8 Collectors类使用详解(实用干货)

Collectors类大家都并不陌生，从jdk1.8开始跟stream()流配合之后，写代码效率得到提升，源码里我们可以看到有很多的方法，比如groupingBy 和maxBy,这些都是干嘛的呢，这篇文章看完都能明白，以下代码简洁明了。

其中有两点需要注意：

1、Collectors.groupingBy强烈推荐,本人代码里使用最频繁的一个方法。

2、用Collectors.toMap方法，在使用的时候需要注意，吧list里面的字段转成map的key和value，当key出现重复的时候会把错，若不想报异常，可以在方法后指定一个新值或者旧值，如何选择，看自己的业务场景决定。（下面第二个例子会有代码详解

3、Collectors.joining方法可以转成字符串，可以指定分隔符号，和字符串前后都能加字符串（下面第五个例子会有代码详解）

1、用groupingBy转成map，本人代码里使用最频繁的一个方法:

 Map<Long, List<FavoriteGroup>> map = favoriteGroupList.stream().collect(
            Collectors.groupingBy(FavoriteGroup::getId));
        System.out.println(map);

2、吧list对象转成map，按标题和id分别为map的key和value。

Map<String, Long> map1 = favoriteGroupList.stream().collect(
            Collectors.toMap(FavoriteGroup::getTitle, FavoriteGroup::getId, (oldValue, newValue) -> newValue));
        System.out.println(map1);

3、summarizingLong方法很有意思，返回的是一个对象，里面有平均值，最大值，总和，最小值，长度，当然如果不需要那么多，也有单独求其中一个值得方法，下面都有详细介绍。

 //最有意思的是这个方法，吧你需要的都可以封装在对象里返回，平均值，最大值，最小值，长度，总和，当然也可以用单独的方法求单独的值，下面也会单独演示一下
        LongSummaryStatistics statistics = favoriteGroupList.stream().map(FavoriteGroup::getId).collect(
            Collectors.summarizingLong(a -> a));
        log.info("平均值:{},最大值:{},最小值:{},总和:{},长度:{}", statistics.getAverage(), statistics.getMax(), statistics.getMin(),
            statistics.getSum(), statistics.getCount());

        //过滤掉空的 标题，并且求count
        Long count = favoriteGroupList.stream().filter(FavoriteGroup -> FavoriteGroup.getTitle() != null).collect(
            Collectors.counting());
        System.out.println(count);

        //maxBy是获取集合里面最大的 id，怎么用呢？minBy同理求最小的 id，下面演示最大id 如何求
        Optional<Long> maxId = favoriteGroupList.stream().map(FavoriteGroup::getId).collect(
            Collectors.maxBy(Long::compare));
        log.info("最大id:{}", maxId.get());

        //下面的方法是求和，
        Long sum = favoriteGroupList.stream().map(FavoriteGroup::getId).collect(
            Collectors.summingLong(a -> a));
        log.info("求和sum:{}", sum);

4、还可以放在concurrentMap中

 //放入concurrentHashMap的用法
        ConcurrentMap<Long, String> concurrentMap = favoriteGroupList.stream().collect(
            Collectors.toConcurrentMap(student -> student.getId(), student -> student.getTitle()));

5、joining方法的使用

        //joining的用法，中间用逗号分割，前面加个start，后面加上end
        String newTitle = favoriteGroupList.stream().map(FavoriteGroup::getTitle).collect(
            Collectors.joining(",", "start", "end")).toString();

6、groupingBy还可以转成map

//groupingBy转成map
        Map<Long, Map<Long, String>> longMapMap = favoriteGroupList.stream().collect(Collectors
            .groupingBy(FavoriteGroup::getId, Collectors.toMap(FavoriteGroup::getId, FavoriteGroup::getTitle)));
        log.info("longMapMap:{}", longMapMap);

7、partitioningBy可以按字段分组，并且可以判断条件，并对条件判断是否满足，返回true和false

  //按title分组，在判断学生id是否大于200
        Map<String,Map<Boolean,List<FavoriteGroup>>> stringMapMap = favoriteGroupList.stream().collect(Collectors.groupingBy(FavoriteGroup::getTitle,
            Collectors.partitioningBy(favoriteGroup -> favoriteGroup.getId() > 200)));
        log.info("stringMapMap:{}",stringMapMap);

8、去重

  static <T> Predicate<T> distinctByKey1(Function<? super T, ?> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

  trackSubList = trackSubList.stream().filter(distinctByKey1(s -> s.getSubWaybillNo())).collect(Collectors.toList());

    public static <K> void addAll(Collection<K> list1, Collection<K> list2) {
        if(CollectionUtil.isEmpty(list2)){
            return;
        }
        list1.addAll(list2);
    }

    /**
     * o 集合 加入 collection
     * @param collection collection
     * @param o o
     * @param <T> T
     */
    public static <T> void add(Collection<T> collection, T o) {
        if(Objects.isNull(o)){
            return;
        }
        collection.add(o);
    }


    /**
     * 通用list转Map
     * @param list list
     * @param keyMapper keyMapper
     * @param <K> K
     * @param <U> U
     * @return
     */
    public static <K,U>  Map<U,K> toIdentityMap(Collection<K> list,
                                                 Function<? super K, U> keyMapper) {
        return list.stream().filter(Objects::nonNull).
                collect(Collectors.toMap(keyMapper,Function.identity(),(oldV, newV)->newV));
    }






   List<String> subListByPre = inOutTaskDTOList.parallelStream().map(inOutTaskDTO -> {
            return inOutTaskDTO.getEwbNoList();
        }).flatMap(Collection::stream).collect(Collectors.toList());