Java 8按收集器分组指南

小鱼儿 2022-11-15 04:59 201阅读 0赞

# 1.介绍 #

使用各种示例来了解groupingBy收集器的工作方式。

# 2.groupingBy Collectors #

Java 8 Stream API能够以声明的方式处理数据集合。

静态工厂方法Collectors.groupingBy()和Collectors.groupingByConcurrent()提供了类似于SQL语言中“ GROUP BY”子句的功能。 使用它们将对象按某些属性分组，并将结果存储在Map实例中。

groupingBy的重载方法是

*  首先，以分类函数作为方法参数：

static <T,K> Collector<T,?,Map<K,List<T>>> 
      groupingBy(Function<? super T,? extends K> classifier)

*  其次，使用分类函数和第二个收集器作为方法参数：

static <T,K,A,D> Collector<T,?,Map<K,D>>
      groupingBy(Function<? super T,? extends K> classifier, 
        Collector<? super T,A,D> downstream)

*  最后，通过分类函数，提供者方法（提供包含最终结果的Map实现）和第二个收集器作为方法参数

static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M>
      groupingBy(Function<? super T,? extends K> classifier, 
        Supplier<M> mapFactory, Collector<? super T,A,D> downstream)

## 2.1示例代码准备 ##

为了演示groupingBy()的用法，让定义一个BlogPost类（将使用BlogPost对象流）：

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class BlogPost { 
        String title;
        String author;
        BlogPostType type;
        int likes;
    }

public enum BlogPostType { 
        /** * */
        NEWS,
        REVIEW,
        GUIDE
    }

定义清单

static List<BlogPost> posts = new ArrayList<>();
       static { 
           posts.add(new BlogPost("map使用用法", "张三", BlogPostType.NEWS,1));
           posts.add(new BlogPost("List使用用法", "李四", BlogPostType.GUIDE,1));
           posts.add(new BlogPost("Set使用用法", "张三", BlogPostType.REVIEW,1));
           posts.add(new BlogPost("Stream使用用法", "赵六", BlogPostType.NEWS,1));
           posts.add(new BlogPost("Thread使用用法", "田七", BlogPostType.GUIDE,1));
       }

还定义一个Tuple类，该类将用于通过组合其类型和作者属性来对帖子进行分组：

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Tuple { 
        BlogPostType type;
        String author;
    }

## 2.2 通过单列进行简单分组 ##

从最简单的groupingBy方法开始，该方法仅将分类函数作为其参数。 分类函数应用于流的每个元素。 使用函数返回的值作为从groupingBy收集器获取的映射的键。

要将博客文章按其类型分组在博客文章列表中，请执行以下操作：

@Test
       public void test1(){ 
           Map<BlogPostType, List<BlogPost>> postsPerType = posts.stream()
                   .collect(groupingBy(BlogPost::getType));
           System.out.println(postsPerType);
       }

输出如下：

{REVIEW=[BlogPost(title=Set使用用法, author=张三, type=REVIEW, likes=1)], NEWS=[BlogPost(title=map使用用法, author=张三, type=NEWS, likes=1), BlogPost(title=Stream使用用法, author=赵六, type=NEWS, likes=1)], GUIDE=[BlogPost(title=List使用用法, author=李四, type=GUIDE, likes=1), BlogPost(title=Thread使用用法, author=田七, type=GUIDE, likes=1)]}

## 2.3通过复杂映射键类型进行分组 ##

分类函数不限于仅返回标量或String值。 只要确保实现必要的equals和hashcode方法，结果映射的键就可以是任何对象。

要将列表中的博客文章按类型和作者（在Tuple实例中组合）进行分组：

@Test
       public  void test2(){ 
           Map<Tuple, List<BlogPost>> postsPerTypeAndAuthor = posts.stream()
                   .collect(groupingBy(post -> new Tuple(post.getType(), post.getAuthor())));
           System.out.println(postsPerTypeAndAuthor);
    
       }

输出

{   Tuple(type=NEWS, author=赵六)=[BlogPost(title=Stream使用用法, author=赵六, type=NEWS, likes=1)],
      Tuple(type=NEWS, author=张三)=[BlogPost(title=map使用用法, author=张三, type=NEWS, likes=1)], 
      Tuple(type=GUIDE, author=李四)=[BlogPost(title=List使用用法, author=李四, type=GUIDE, likes=1)], 
      Tuple(type=GUIDE, author=田七)=[BlogPost(title=Thread使用用法, author=田七, type=GUIDE, likes=1)], 
      Tuple(type=REVIEW, author=张三)=[BlogPost(title=Set使用用法, author=张三, type=REVIEW, likes=1)]}

## 2.4修改返回的Map值类型 ##

groupingBy的第二次重载使用了一个附加的第二收集器（下游收集器），该收集器应用于第一收集器的结果。

指定分类函数但不指定下游收集器时，将在后台使用toList()收集器。

使用toSet()收集器作为下游收集器，并获取一组博客文章（而不是List）：

@Test
       public  void test3(){
           Map<BlogPostType, Set<BlogPost>> postsPerType = posts.stream()
                   .collect(groupingBy(BlogPost::getType, toSet()));
           System.out.println(postsPerType);
       }

输出

{REVIEW=[BlogPost(title=Set使用用法, author=张三, type=REVIEW, likes=1)], 
    NEWS=[BlogPost(title=map使用用法, author=张三, type=NEWS, likes=1),
    BlogPost(title=Stream使用用法, author=赵六, type=NEWS, likes=1)], 
    GUIDE=[BlogPost(title=Thread使用用法, author=田七, type=GUIDE, likes=1), 
    BlogPost(title=List使用用法, author=李四, type=GUIDE, likes=1)]}

## 2.5按多个字段分组 ##

下游收集器的另一种应用是对第一组的结果进行二级分组。

要按作者然后按类型对BlogPost列表进行分组：

@Test
       public  void test4(){ 
           Map<String, Map<BlogPostType, List<BlogPost>>> map = posts.stream()
                   .collect(groupingBy(BlogPost::getAuthor, groupingBy(BlogPost::getType)));
           System.out.println(map);
       }

输出

{李四={GUIDE=[BlogPost(title=List使用用法, author=李四, type=GUIDE, likes=1)]}, 
    张三={REVIEW=[BlogPost(title=Set使用用法, author=张三, type=REVIEW, likes=1)], NEWS=[BlogPost(title=map使用用法, author=张三, type=NEWS, likes=1)]}, 
    赵六={NEWS=[BlogPost(title=Stream使用用法, author=赵六, type=NEWS, likes=1)]}, 
    田七={GUIDE=[BlogPost(title=Thread使用用法, author=田七, type=GUIDE, likes=1)]}}

## 2.6从分组结果中获取平均值 ##

通过使用下游收集器，可以将聚合函数应用到分类函数的结果中。

例如，要查找每种博客文章类型的平均点赞次数：

@Test
       public void test5(){ 
           Map<BlogPostType, Double> averageLikesPerType = posts.stream()
                   .collect(groupingBy(BlogPost::getType, averagingInt(BlogPost::getLikes)));
           System.out.println(averageLikesPerType);
       }

输出

{ NEWS=1.0, GUIDE=1.0, REVIEW=1.0}

## 2.7从分组结果中获取总和 ##

要计算每种类型的喜欢总数：

@Test
       public void test6(){ 
           Map<BlogPostType, Integer> likesPerType = posts.stream()
                   .collect(groupingBy(BlogPost::getType, summingInt(BlogPost::getLikes)));
           System.out.println(likesPerType);
       }

输出

{NEWS=2, GUIDE=2, REVIEW=1}

## 2.8从分组结果中获取最大值或最小值 ##

可以执行的另一种汇总方式是获得具有最多“赞”次数的博客帖子：

@Test
       public void test7(){ 
           Map<BlogPostType, Optional<BlogPost>> maxLikesPerPostType = posts.stream()
                   .collect(groupingBy(BlogPost::getType,
                           maxBy(comparingInt(BlogPost::getLikes))));
           System.out.println(maxLikesPerPostType);
    
       }

输出

{
    GUIDE=Optional[BlogPost(title=List使用用法, author=李四, type=GUIDE, likes=1)], 
    NEWS=Optional[BlogPost(title=map使用用法, author=张三, type=NEWS, likes=1)], 
    REVIEW=Optional[BlogPost(title=Set使用用法, author=张三, type=REVIEW, likes=1)]
    }

同样，我们可以应用minBy下游收集器来获得具有最少点赞次数的博客文章。

请注意，maxBy和minBy收集器考虑了应用它们的集合可能为空的可能性。 这就是为什么映射中的值类型为Optional 的原因。

## 2.9获取分组结果属性的总和 ##

Collectors API提供了一个汇总收集器，可以在需要同时计算数值属性的计数，总和，最小值，最大值和平均值的情况下使用。

每种不同类型的博客文章的likes属性计算一个总和：

@Test
       public void test8(){ 
           Map<BlogPostType, IntSummaryStatistics> likeStatisticsPerType = posts.stream()
                   .collect(groupingBy(BlogPost::getType,
                           summarizingInt(BlogPost::getLikes)));
    
           System.out.println(likeStatisticsPerType);
       }

输出

{
     REVIEW=IntSummaryStatistics{count=1, sum=1, min=1, average=1.000000, max=1}, 
     NEWS=IntSummaryStatistics{count=2, sum=2, min=1, average=1.000000, max=1}, 
     GUIDE=IntSummaryStatistics{count=2, sum=2, min=1, average=1.000000, max=1}
     }

## 2.10将分组结果映射到其他类型 ##

通过将映射下游收集器应用于分类函数的结果，可以实现更复杂的聚合。

连接每种博客文章类型的文章标题：

@Test
       public void test9(){ 
           Map<BlogPostType, String> postsPerType = posts.stream()
                   .collect(groupingBy(BlogPost::getType,
                           mapping(BlogPost::getTitle, joining(", ", "Post titles: [", "]"))));
           System.out.println(postsPerType);
       }

输出

{ 
    REVIEW=Post titles: [Set使用用法], 
    NEWS=Post titles: [map使用用法, Stream使用用法], 
    GUIDE=Post titles: [List使用用法, Thread使用用法]
    }

## 2.11修改返回Map类型 ##

使用groupingBy收集器时，无法对返回的Map的类型进行假设。 如果要具体确定要从分组依据中获取哪种类型的地图，则可以使用groupingBy方法的第三个变体，该方法允许通过传递Map类型来更改地图的类型。

接下来将EnumMap提供程序函数传递给groupingBy方法来检索EnumMap：

@Test
       public void test10(){ 
           EnumMap<BlogPostType, List<BlogPost>> postsPerType = posts.stream()
                   .collect(groupingBy(BlogPost::getType,
                           () -> new EnumMap<>(BlogPostType.class), toList()));
           System.out.println(postsPerType);
       }

输出：

{ 
    NEWS=[BlogPost(title=map使用用法, author=张三, type=NEWS, likes=1), BlogPost(title=Stream使用用法, author=赵六, type=NEWS, likes=1)], 
    REVIEW=[BlogPost(title=Set使用用法, author=张三, type=REVIEW, likes=1)], 
    GUIDE=[BlogPost(title=List使用用法, author=李四, type=GUIDE, likes=1), BlogPost(title=Thread使用用法, author=田七, type=GUIDE, likes=1)]
    }

## 2.12分组返回并发收集器 ##

与groupingBy类似的是groupingByConcurrent收集器，该收集器利用了多核体系结构。 该收集器具有三个重载方法，它们采用与groupingBy收集器的各个重载方法完全相同的参数。 但是，groupingByConcurrent收集器的返回类型必须是ConcurrentHashMap类的实例或其子类。

要同时执行分组操作，流必须是并行的：

@Test
       public  void test11(){ 
           ConcurrentMap<BlogPostType, List<BlogPost>> postsPerType = posts.parallelStream()
                   .collect(groupingByConcurrent(BlogPost::getType));
           System.out.println(postsPerType);
       }

输出

{
    GUIDE=[BlogPost(title=Thread使用用法, author=田七, type=GUIDE, likes=1), BlogPost(title=List使用用法, author=李四, type=GUIDE, likes=1)], 
    NEWS=[BlogPost(title=Stream使用用法, author=赵六, type=NEWS, likes=1), BlogPost(title=map使用用法, author=张三, type=NEWS, likes=1)], REVIEW=[BlogPost(title=Set使用用法, author=张三, type=REVIEW, likes=1)]
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pdWdhbmcwOTIw_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pdWdhbmcwOTIw_size_16_color_FFFFFF_t_70]: /images/20221022/b980dd18aebe4b60aa086f91ddf78590.png