使用 Java 流进行分组和聚合,高效处理大量数据不再是梦!

这篇具有很好参考价值的文章主要介绍了使用 Java 流进行分组和聚合,高效处理大量数据不再是梦!。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

了解使用 Java Streams 解决问题的直接途径,Java Streams 是一个允许我们快速有效地处理大量数据的框架。

当我们对列表中的元素进行分组时,我们可以随后聚合分组元素的字段以执行有意义的操作,帮助我们分析数据。一些示例是加法、平均值或最大值/最小值。这些单个字段的聚合可以使用 Java Streams 和 Collectors 轻松完成。该文档提供了如何进行这些类型计算的简单示例。

但是,还有更复杂的聚合,例如加权平均值、几何平均值。此外,可能需要同时聚合多个字段。在本文中,我们将展示使用 Java Streams 解决此类问题的直接途径。使用这个框架使我们能够快速有效地处理大量数据。

我们假设读者对Java Streams和实用程序Collectors类有基本的了解。

问题布局

让我们考虑一个简单的例子来展示我们想要解决的问题类型。我们将使它非常通用,以便我们可以轻松地概括它。让我们考虑TaxEntry由以下代码定义的实体列表:

public class TaxEntry {

    private String state;
    private String city;
    private int numEntries;
    private double price;
    //Constructors, getters, hashCode, equals etc
}

计算给定城市的条目总数非常简单:

Map<String, Integer> totalNumEntriesByCity = 
              taxes.stream().collect(Collectors.groupingBy(TaxEntry::getCity, 
                                                           Collectors.summingInt(TaxEntry::getNumEntries)));

Collectors.summingInt(TaxEntry::getNumEntries)));

Collectors.groupingBy接受两个参数:一个分类器函数进行分组,一个收集器对属于给定组的所有元素进行下游聚合。我们TaxEntry::getCity用作分类器函数。对于下游,我们使用Collectors::summingIntwhich 返回一个Collector总和我们为每个分组元素获得的税收条目的数量。

如果我们尝试找到复合分组,事情会稍微复杂一些。例如,对于前面的示例,给定州和 城市的条目总数。有几种方法可以做到这一点,但一个非常简单的方法是首先定义:

record StateCityGroup(String state, String city) {}

请注意,我们使用的是 Javarecord,这是一种定义不可变类的简洁方法。此外,Java 编译器为我们生成字段访问器方法hashCode、、等号和toString实现。有了这个,现在的解决方案很简单:

Map<StateCityGroup, Integer> totalNumEntriesForStateCity = 
                    taxes.stream().collect(groupingBy(p -> new StateCityGroup(p.getState(), p.getCity()), 
                                                      Collectors.summingInt(TaxEntrySimple::getNumEntries))
                                          );

因为Collectors::groupingBy我们使用 lambda 表达式设置分类器函数,该表达式创建一个StateCityGroup封装每个州-城市的新记录。下游 Collector 和之前一样。

注意:为了简洁起见,在代码示例中,我们将假设 Collectors 类的所有方法都是静态导入的,因此我们不必显示它们的类限定。

如果我们想同时进行多个聚合,事情开始变得更加复杂。例如,查找给定州和城市的条目数和平均价格之和。该库没有为这个问题提供简单的解决方案。

为了开始解决这个问题,我们从之前的聚合中获取线索,并定义一个记录来封装所有需要聚合的字段:

record TaxEntryAggregation (int totalNumEntries, double averagePrice ) {}

现在,我们如何同时对两个字段进行聚合?正如以下代码中所建议的那样,总是有可能进行两次流收集以分别查找每个聚合:

Map<StateCityGroup, TaxEntryAggregation> aggregationByStateCity = taxes.stream().collect(
           groupingBy(p -> new StateCityGroup(p.getState(), p.getCity()),
                      collectingAndThen(Collectors.toList(), 
                                        list -> {int entries = list.stream().collect(
                                                                   summingInt(TaxEntrySimple::getNumEntries));
                                                 double priceAverage = list.stream().collect(
                                                                   averagingDouble(TaxEntrySimple::getPrice));
                                                 return new TaxEntryAggregation(entries, priceAverage);})));

分组像以前一样完成,但对于下游,我们使用Collectors::collectingAndThen(第 3 行)进行聚合。这个函数有两个参数:

  • 我们转换为列表的初始分组的下载流(Collectors::toList()在第 3 行中使用)
  • Finisher 函数(第 4-9 行),我们使用 lambda 表达式从前一个列表中创建两个不同的流来进行聚合并将它们组合在一个新TaxEntryAggregation记录 中返回

想象一下,我们想同时进行更多的字段聚合。我们需要相应地增加下游列表中的流数量。代码变得效率低下、重复性非常高且不太理想。我们应该寻找更好的替代品。

此外,问题还不止于此,一般来说,我们受限于可以使用 Collectors 辅助类进行的聚合类型。他们的方法 summing*、averaging* 和 summarizing* 仅支持整数、长整数和双精度本机类型。如果我们有更复杂的类型,比如BigIntegeror ,我们该怎么办BigDecimal

雪上加霜的是,summarizing* 方法仅提供 min、max、count、sum 和 average 的汇总统计数据。如果我们想要执行更复杂的计算,例如加权平均值或几何平均值怎么办?

有些人会争辩说我们总是可以编写自定义收集器,但这需要了解收集器接口并很好地理解流收集器流程。使用 Collectors 类中的实用方法提供的内置收集器更直接。在下一节中,我们将展示一些关于如何实现此目的的策略。

复杂的多重聚合:解决路径

让我们考虑一个简单的例子,它将突出我们在上一节中提到的挑战。假设我们有以下实体:

public class TaxEntry {
    private String state;
    private String city;
    private BigDecimal rate;
    private BigDecimal price;
    record StateCityGroup(String state, String city) {
    }
    //Constructors, getters, hashCode/equals etc
}

我们首先询问每个不同的州-城市对如何找到条目的总数以及rateprice(∑(rate * price)) 的乘积的总和。请注意,我们正在使用BigDecimal.

正如我们在上一节中所做的那样,我们定义了一个封装聚合的类:

record RatePriceAggregation(int count, BigDecimal ratePrice) {}

起初可能看起来令人惊讶,但是对于后面跟着简单聚合的分组的直接解决方案是使用Collectors::toMap.让我们看看我们将如何做到这一点:

Map<StateCityGroup, RatePriceAggregation> mapAggregation = taxes.stream().collect(
      toMap(p -> new StateCityGroup(p.getState(), p.getCity()), 
            p -> new RatePriceAggregation(1, p.getRate().multiply(p.getPrice())), 
            (u1,u2) -> new RatePriceAggregation( u1.count() + u2.count(), u1.ratePrice().add(u2.ratePrice()))
            ));

(第Collectors::toMap2 行)接受三个参数,我们执行以下实现:

  • 第一个参数是一个 lambda 表达式,用于生成地图的键。此函数创建StateCityGroup为地图的键。这将按州和城市对元素进行分组(第 2 行)。
  • 第二个参数产生地图的值。在我们的例子中,我们创建了RatePriceAggregation一个计数为 1 以及 rate 和 price 的乘积的初始化(第 3 行)。
  • 最后,最后一个参数是BinaryOperator用于合并多个元素映射到同一个州-城市键的情况。我们将计数和价格相加以进行汇总(第 4 行)。

让我们演示如何设置一些示例数据:

List<TaxEntry> taxes = Arrays.asList(
                          new TaxEntry("New York", "NYC", BigDecimal.valueOf(0.2), BigDecimal.valueOf(20.0)), 
                          new TaxEntry("New York", "NYC", BigDecimal.valueOf(0.4), BigDecimal.valueOf(10.0)), 
                          new TaxEntry("New York", "NYC", BigDecimal.valueOf(0.6), BigDecimal.valueOf(10.0)), 
                          new TaxEntry("Florida", "Orlando", BigDecimal.valueOf(0.3), BigDecimal.valueOf(13.0)));

从前面的代码示例中获取纽约的结果很简单:

System.out.println("New York: " + mapAggregation.get(new StateCityGroup("New York", "NYC")));

这打印:

New York: RatePriceAggregation[count=3, ratePrice=14.00]

这是一个直接的实现,它决定了多个字段和非原始数据类型(BigDecimal在我们的例子中)的分组和聚合。但是,它的缺点是它没有任何终结器允许您执行额外的操作。例如,你不能做任何类型的平均值。

为了展示这个问题,让我们考虑一个更复杂的问题。假设我们想要找到费率-价格的加权平均值,以及每个州和城市对的所有价格的总和。特别是,要找到加权平均值,我们需要计算属于每个州-城市对的所有条目的费率和价格的乘积之和,然后除以每个案例的条目总数 n: 1/n ∑(费率 * 价格)。

为了解决这个问题,我们开始定义一个包含聚合的记录:

record TaxEntryAggregation(int count, BigDecimal weightedAveragePrice, BigDecimal totalPrice) {}

有了这个,我们可以进行以下实现:

Map<StateCityGroup, TaxEntryAggregation> groupByAggregation = taxes.stream().collect(
    groupingBy(p -> new StateCityGroup(p.getState(), p.getCity()), 
               mapping(p -> new TaxEntryAggregation(1, p.getRate().multiply(p.getPrice()), p.getPrice()), 
                       collectingAndThen(reducing(new TaxEntryAggregation(0, BigDecimal.ZERO, BigDecimal.ZERO),
                                                  (u1,u2) -> new TaxEntryAggregation(u1.count() + u2.count(),
                                                      u1.weightedAveragePrice().add(u2.weightedAveragePrice()), 
                                                      u1.totalPrice().add(u2.totalPrice()))
                                                  ),
                                         u -> new TaxEntryAggregation(u.count(), 
                                                 u.weightedAveragePrice().divide(BigDecimal.valueOf(u.count()),
                                                                                 2, RoundingMode.HALF_DOWN), 
                                                 u.totalPrice())
                                         )
                      )
              ));

我们可以看到代码稍微复杂一些,但可以让我们得到我们正在寻找的解决方案。我们将更详细地关注它:

  • Collectors::groupingBy(第 2 行):
  1. 对于分类功能,我们创建一个StateCityGroup 记录
  2. 对于下游,我们调用Collectors::mapping(第 3 行):
  • 对于第一个参数,我们应用于输入元素的映射器将分组的州-城市税收记录转换为TaxEntryAggregation将初始计数分配为 1 的新条目,将税率乘以价格,然后设置价格(第 3 行)。
  • 对于下游,我们调用Collectors::collectingAndThen(第 4 行),正如我们将看到的,这将允许我们对下游收集器应用一个完成转换。
    • 调用Collectors::reducing(第 4 行)
  1. 创建一个默认值TaxEntryAggregation 以涵盖没有下游元素的情况(第 4 行)。
  2. Lambda 表达式进行归约并返回一个TaxEntryAggregation包含字段聚合的新表达式(第 5、6 7 行)
  • 使用在先前归约中计算的计数执行完成转换,计算平均值并返回最终结果TaxEntryAggregation(第 9、10、11 行)。

我们看到这种实现不仅允许我们同时进行多个字段聚合,而且还可以在多个阶段执行复杂的计算。

这可以很容易地推广到解决更复杂的问题。路径很简单:定义一条记录,封装所有需要聚合的字段,Collectors::mapping用来初始化记录,然后申请Collectors::collectingAndThen做归约和最终聚合。

和以前一样,我们可以获得纽约的聚合:

System.out.println("Finished aggregation: " + groupByAggregation.get(new StateCityGroup("New York", "NYC")));

我们得到结果:

Finished aggregation: TaxEntryAggregation[count=3, weightedAveragePrice=4.67, totalPrice=40.0]

还值得指出的是,由于TaxEntryAggregation是 Java record,它是不可变的,因此可以使用流收集器库提供的​​支持来并行计算。

结论

我们已经展示了几种策略来使用聚合进行复杂的多字段分组,这些聚合包括具有多字段和跨字段计算的非原始数据类型。这是一个使用 Java 流和 Collectors API 的记录列表,因此它为我们提供了快速有效地处理大量数据的能力。文章来源地址https://www.toymoban.com/news/detail-732724.html

到了这里,关于使用 Java 流进行分组和聚合,高效处理大量数据不再是梦!的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java Elasticsearch多条件分组聚合查询

    需求         在项目开发中,需要从elasticsearch中查询日志数据,先统计每一天的日志调用量,然后在每一天的分组聚合基础上,再分组聚合统计成功和失败的日志调用量。 代码

    2024年02月08日
    浏览(55)
  • 使用Elasticsearch处理大量数据,如何翻页查询

    当使用Elasticsearch处理大量数据时,从第一页直接跳转到第100页进行查询确实是一个挑战,因为需要计算跳过的记录数并有效地获取目标页的数据。以下是一些建议来实现这种跳页查询: 使用 from 和 size 参数 : Elasticsearch提供了 from 和 size 参数来实现分页。 from 参数指定了要

    2024年04月15日
    浏览(64)
  • group by聚合分组后如何获取分组数据

    之前用group by分组后一直困惑怎么把分组后的数据拿到,因为分组后同一组的只有一条数据,最后发现了 group_concat函数。记录一下,以后能用。 语法:group_concat( [distinct] 要连接的字段 [order by 排序字段 asc/desc ] [separator \\\'分隔符\\\'] ) 说明:通过使用 distinct 可以排除重复值(去重

    2024年02月05日
    浏览(44)
  • 数据分析 — Pandas 分组聚合

    pandas.apply() 是 Pandas 库中的一个函数,用于在 DataFrame 或 Series 上应用自定义函数。这个函数可以 沿着指定的轴(行或列)逐行或逐列地应用函数 ,从而实现对数据的定制化操作。 参数: func(必需):这是要应用的函数,可以是一个 Python 函数、lambda 函数或可调用对象。这

    2024年02月19日
    浏览(46)
  • Java 8 Stream实用篇,玩转集合的筛选、归约、分组、聚合

    Stream将要处理的元素集合看作一种流,在流的过程中,借助Stream API对流中的元素进行操作,比如:筛选、排序、聚合等。 Stream可以由数组或集合创建,对流的操作分为两种: 中间操作 ,每次返回一个新的流,可以有多个。 终端操作 ,每个流只能进行一次终端操作,终端操

    2024年01月20日
    浏览(71)
  • 如何使用Puppeteer进行新闻网站数据抓取和聚合

    Puppeteer是一个基于Node.js的库,它提供了一个高级的API来控制Chrome或Chromium浏览器。通过Puppeteer,我们可以实现各种自动化任务,如网页截图、PDF生成、表单填写、网络监控等。本文将介绍如何使用Puppeteer进行新闻网站数据抓取和聚合,以网易新闻和杭州亚运会为例。 数据抓取

    2024年02月10日
    浏览(65)
  • 分组聚合不再难:Pandas groupby使用指南

    处理大量数据时,经常需要对数据进行分组和汇总, groupby 为我们提供了一种简洁、高效的方式来实现这些操作,从而简化了数据分析的流程。 分组 是指根据一个或多个列的值将数据分成多个组,每个组包含具有相同键值(这里的键值即用来分组的列值)的数据行。 聚合

    2024年03月09日
    浏览(44)
  • 【算法】在vue3的ts代码中分组group聚合源数据列表

    有一个IListany()对象列表, 示例数据为[{id:\\\'1\\\',fieldName:\\\'field1\\\',value:\\\'1\\\'},{id:\\\'1\\\',fieldName:\\\'field2\\\',value:\\\'2\\\'},{id:\\\'2\\\',fieldName:\\\'field1\\\',value:\\\'1\\\'},{id:\\\'2\\\',fieldName:\\\'field2\\\',value:\\\'2\\\'}] 那么在ts中将它们根据id分组构建为两个dynamicObject,类推,如果id有n个,那需要自动构建n个dynamicObject。 算法实现: 在以

    2024年02月11日
    浏览(40)
  • 使用java8 新特性stream流对List<Map<String, Object>>集合进行遍历、过滤、查询、去重、排序、分组

    对于一个ListMapString, Object类型的数据,可以使用Java 8的新特性stream流来进行遍历、过滤、查询、去重、排序、分组等操作。 遍历: 过滤: 查询: 去重: 排序: 分组:

    2024年02月10日
    浏览(69)
  • 【数据库】通过实例讲清楚,Mongodb的增删查改,分组查询,聚合查询aggregate

    目录 一.基础概念 二.数据库的管理 1.创建数据库 2.删除数据库 二.集合的管理 1.显示所有集合 2.创建集合 3.删除当前集合 4.向集合中插入元素 三.文档的管理 1.文档插入 2.文档的更新 3.文档的删除 4.文档查询 (1)查询基本语法: (2)查询table2集合下的所有文档 (3)查询t

    2024年02月10日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包