前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >java8实战:使用流收集数据之toList、joining、groupBy(多字段分组)

java8实战:使用流收集数据之toList、joining、groupBy(多字段分组)

作者头像
beifengtz
发布2019-07-10 15:36:07
1.1K0
发布2019-07-10 15:36:07
举报
文章被收录于专栏:北风IT之路

本文将从Collectos中构建收集器入手,详细介绍java8提供了哪些收集器,重点介绍:toList、toSet、toCollection、joining、groupBy(包含多级分组)、reducing的核心实现原理与使用示例。

集合类操作

集合类操作包含toList、toSet、toCollection。首先对流中的数据进行计算,最终返回的数据类型为集合。Collectors中定义了如下3集合类收集器,其声明如下:

代码语言:javascript
复制
1public static <T> Collector<T, ?, List<T>> toList()
2public static <T> Collector<T, ?, Set<T>> toSet()
3public static <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory)

温馨提示:建议根据上篇的理论,再来反推一下这些Collector中的核心属性的值,例如supplier、accumulator、combiner、characteristics。不过特别注意,toList、toCollection是不支持并行运行的,但toSet()方法支持并行运行。

我们首先来看一个一直使用的示例,返回菜单中所有菜品的名称:

代码语言:javascript
复制
1public static void test_toList(List<Dish> menu) {
2    List<String> names = menu.stream().map(Dish::getName)
3                        .collect(Collectors.toList());
4}

joining

Collectors定义了如下3个重载方法。

代码语言:javascript
复制
1public static Collector<CharSequence, ?, String> joining()
2public static Collector<CharSequence, ?, String> joining(CharSequence delimiter)
3public static Collector<CharSequence, ?, String> joining(CharSequence delimiter,
4    CharSequence prefix, CharSequence suffix)
2.1 joining
代码语言:javascript
复制
1public static Collector<CharSequence, ?, String> joining() {
2    return new CollectorImpl<CharSequence, StringBuilder, String>(
3        StringBuilder::new, StringBuilder::append,
4        (r1, r2) -> { r1.append(r2); return r1; },
5        StringBuilder::toString, CH_NOID);
6}
  • Supplier< A> supplier() 其函数为StringBuilder::new,即通过该方法创建一个StringBuilder方法,作为累积器的初始值。
  • BiConsumer accumulator 累积器:StringBuilder::append,即会对流中的元素执行追加。
  • BinaryOperator< A> combiner 组合器,也是调用append方法,进行字符串的规约。
  • Function finisher 转换器:由于累积器返回的最终对象为StringBuilder,并不是目标String类型,故需要调用StringBuilder#toString方法进行转换
  • Set< Characteristics> characteristics 无任何行为。

从上面的函数定义我们可以得出该方法的作用:针对字符串流,会对流中的元素执行字符的追加动作,流元素之间没有分隔符号,示例如下:

2.2 joining(CharSequence delimiter)
代码语言:javascript
复制
 1public static Collector<CharSequence, ?, String> joining(CharSequence delimiter) {
 2    return joining(delimiter, "", "");
 3}
 4public static Collector<CharSequence, ?, String> joining(CharSequence delimiter,
 5                                                         CharSequence prefix,
 6                                                         CharSequence suffix) {
 7    return new CollectorImpl<>(
 8            () -> new StringJoiner(delimiter, prefix, suffix),
 9            StringJoiner::add, StringJoiner::merge,
10            StringJoiner::toString, CH_NOID);
11}
  • Supplier< A> supplier() 其函数为() -> new StringJoiner(delimiter, prefix, suffix),累积器的初始值为StringJoiner。
  • BiConsumer accumulator 累积器:StringJoiner::append,即会对流中的元素执行追加。
  • BinaryOperator< A> combiner 组合器,StringJoiner::merge。
  • Function finisher 转换器:由于累积器返回的最终对象为StringBuilder,并不是目标String类型,故需要调用StringBuilder#toString方法进行转换
  • Set< Characteristics> characteristics 无任何行为。

其示例如下:

聚合相关收集器

聚合相关收集器,主要包括minBy、maxBy、sum、avg等相关函数,其主要方法声明如下:

代码语言:javascript
复制
1public static <T> Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator)
2public static <T> Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator)
3public static <T> Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper)
4public static <T> Collector<T, ?, Long> summingLong(ToLongFunction<? super T> mapper)
5public static <T> Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper)
6public static <T> Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper)
7public static <T> Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper)
8public static <T> Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper)

上面这些方法比较简单,下面举个简单的例子介绍其使用:

分组

Collectors提供了3个groupingBy重载方法,我们一个一个来理解。

4.1 从示例入手

我们从其中一个最简单的函数说起,从而慢慢引出

代码语言:javascript
复制
1public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(
2             Function<? super T, ? extends K> classifier)
  • Collector>> 首先我们先来关注该方法的返回值Collector<T, ?, Map<K,List< T>>,其最终返回的数据类型为:Map<K, List< T >>
  • Function classifier 分类函数。

示例如下:例如如下是购物车实体类,并且初始化数据如下:

代码语言:javascript
复制
 1public class ShopCar {
 2    private int id;
 3    private int sellerId;
 4    private String sellerName;
 5    private String goodsName;
 6    private int buyerId;
 7    private String buyerName;
 8    private int num;
 9}
10// 初始化数据如下:
11public static List<ShopCar> initShopCar() {
12    return Arrays.asList(
13            new ShopCar(1, 1, "天猫" , "华为手机", 1 , "dingw", 5),
14            new ShopCar(1, 2, "京东" , "华为手机", 2 , "ly", 2),
15            new ShopCar(1, 1, "京东" , "小米手机", 3 , "zhl", 3),
16            new ShopCar(1, 2, "1号店" , "华为手机", 1 , "dingw", 5),
17            new ShopCar(1, 2, "天猫" , "苹果手机", 1 , "dingw", 2)
18    );
19}

首先我们看一下java8之前的写法:

代码语言:javascript
复制
 1public static void test_group_jdk7(List<ShopCar> shopCars) {
 2    Map<String, List<ShopCar>> shopBySellerNameMap = new HashMap<>();
 3    for(ShopCar c : shopCars ) {
 4        if(shopBySellerNameMap.containsKey( c.getSellerName() )) {
 5            shopBySellerNameMap.get(c.getSellerName()).add(c);
 6        } else {
 7            List<ShopCar> aList = new ArrayList<>();
 8            shopBySellerNameMap.put(c.getSellerName(), aList);
 9            aList.add(c);
10        }
11    }
12    print(shopBySellerNameMap);
13}

上面的代码应该很容易理解,根据商家名称进行分组,拥有相同商家的名称的购物车项组成一个集合,最终返回Map>类型的数据。

那如何使用java8的流分组特性来编写对应的代码呢?下面的思考过程非常关键,经过前面的学习,我想大家应该也具备了如下分析与编写的能力?

首先其声明如下:public static Collector>> groupingBy(Function classifier),那在本例中,T,K这两个参数代表什么意思呢?

  • T : ShopCar
  • K : String (sellerName的类型) 其判断的主要依据为groupingBy方法返回的参数Collector< T, ?, Map< K, List< T>>>,代表< T, A, R>,其中最后一个泛型参数R对应的就是本例需要返回的Map< K, List< T>>,故分析出T,K代表的含义。

然后再看其参数:Function classifier,即接受的函数式编程接口为T -> K,即通过ShopCar 返回一个String,又根据其名称可知,该函数为一个分类函数,故基本可以写成如下代码:

代码语言:javascript
复制
1public static void test_group_jdk8(List<ShopCar> shopCars) {
2    Map<String, List<ShopCar>> shopBySellerNameMap =  
3                 shopCars
4                     .stream()
5                     .collect(Collectors.groupingBy(ShopCar::getSellerName));
6                   //.collect(Collectors.groupingBy( (ShopCar c) -> c.getSellerName() ))
7    print(shopBySellerNameMap);
8}

其运行效果如下:

为了加深对groupingBy方法的理解,接下来我们重点分析一下其源码的实现。

4.2 源码分析groupingBy方法
代码语言:javascript
复制
1public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier) {  // @1
2    return groupingBy(classifier, toList());                                                                     // @2
3}

代码@1:分类参数,已经在上文中详细介绍。

代码@2:调用groupingBy重载方法,传入的参数为toList(),有点意思,传入的参数为Collectors.toList(),结合上文中的示例,需要返回值类为:Map< String, List< ShopCar>>,与这里的List对应起来了。

代码语言:javascript
复制
1public static <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) {
2    return groupingBy(classifier, HashMap::new, downstream);
3}
该重载方法,再次调用3个参数的groupingBy方法。
代码语言:javascript
复制
 1public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(
 2                          Function<? super T, ? extends K> classifier, 
 3Supplier<M> mapFactory,
 4Collector<? super T, A, D> downstream) { // @1
 5    Supplier<A> downstreamSupplier = downstream.supplier();        // @2 start
 6    BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
 7    BiConsumer<Map<K, A>, T> accumulator = (m, t) -> {
 8        K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
 9        A container = m.computeIfAbsent(key, k -> downstreamSupplier.get());
10        downstreamAccumulator.accept(container, t);
11    }; // @2 end
12
13    BinaryOperator<Map<K, A>> merger = Collectors.<K, A, Map<K, A>>mapMerger(downstream.combiner());   // @3
14    @SuppressWarnings("unchecked")
15    Supplier<Map<K, A>> mangledFactory = (Supplier<Map<K, A>>) mapFactory;                            
16
17    if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {           // @4
18        return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID);
19    }
20    else {                                                                                            // @5
21        @SuppressWarnings("unchecked")
22        Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();
23        Function<Map<K, A>, M> finisher = intermediate -> {
24            intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
25            @SuppressWarnings("unchecked")
26            M castResult = (M) intermediate;
27            return castResult;
28        };
29        return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID);
30    }
31}

代码@1:参数介绍:

  • Function classifier 分类函数。
  • Supplier< M> mapFactory map构建函数。()-> Map
  • Collector downstream 下游收集器,在上面的示例中,该参数为Collectos.toList()。

代码@2:构建最终的累积器。其实现要点如下:

  • 对流中的元素,使用Function classifier,获取对应的分类键值。
  • 使用mangledFactory创建累积初始值,并调用Map#computeIfAbsent方法,放入的值为:downstreamSupplier.get()。可以类比上例中Map>,请结合如下代码进行理解:

代码@3:构建最终的组合器,这里使用的是Collectos.mapMerger,其内部的实现就是对每个元素,执行map#merge方法。

代码@4:如果收集器的行为为IDENTITY_FINISH,直接根据上面已创建的累积器、组合器,创建一个最终的收集器。

代码@5:如果收集器的行为不包含IDENTITY_FINISH,则需要最终调用原收集器的finisher方法。才能最终需要返回的类型。

groupingBy的原理就讲解到这里,我们接下来思考如下场景: 还是上面的购物车场景,现在要求先按照供应商名称分组,然后按照购买人分组(即多级分组),类似于SQL group by sellerId,buyerId。

思考过程:首先二级分类需要返回的数据类型为Map> >,而只有一个参数的groupingBy(Function classifier),只接受一个分类参数,其内部会调用两个参数的groupingBy(Function classifier,Collector downstream),默认第二个参数为Collectors.toList(),故我们可以做的文章是改变这个默认值,传入符合业务场景的收集器,结合目前的需求,很显然,该参数应该是支持分组的收集器,即应该可以通过嵌套groupingBy方法,实现二级分组,其具体代码如下:

代码语言:javascript
复制
 1/**
 2 * 二级分组示例
 3 * @param shopCars
 4 */
 5public static void test_level_group(List<ShopCar> shopCars) {
 6    Map<String, Map<String, List<ShopCar>>>  result = 
 7        shopCars.stream().collect(Collectors.groupingBy(ShopCar::getSellerName,
 8                                    Collectors.groupingBy(ShopCar::getBuyerName)));
 9    System.out.println(result);
10}

温馨提示:上面介绍的分组,主要的Map存储结构为HashMap,java8为ConcurrentMap对应类继承体系提供了对应的分组函数:groupingByConcurrent,其使用方法与groupingBy方法类型,故不重复介绍。

partitioningBy

分区,分区可以看出是分组的特殊化,接受的分类函数返回boolean类型,即是谓词Predicate predicate。其声明如下:

代码语言:javascript
复制
1public static <T> Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate)
2public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) 

由于其用法与分组类似,故这里就一笔带过了。

reducing

规约。其函数声明如下:

代码语言:javascript
复制
1public static <T, U> Collector<T, ?, U> reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator<U> op)

其参数如下:

  • U identity 规约初始值。
  • Function mapper 累加器函数。
  • BinaryOperator op 组合器函数。

END

本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2019-06-28,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 北风IT之路 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 集合类操作
  • joining
    • 2.1 joining
      • 2.2 joining(CharSequence delimiter)
      • 聚合相关收集器
      • 分组
        • 4.1 从示例入手
          • 4.2 源码分析groupingBy方法
          • partitioningBy
          • reducing
          领券
          问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档