用Java流进行分组和聚集

学习使用JavaStreams解决问题的简单方法，这是一个允许我们快速有效地处理大量数据的框架。

当我们从列表中对元素进行分组时，我们可以随后聚合分组元素的字段，以执行有意义的操作，帮助我们分析数据。一些例子是加法、平均值或最大值/分钟值。这些单个字段的聚合可以很容易地使用Java流和收集器来完成。文档提供了如何进行这些类型计算的简单示例。

然而，还有更复杂的集合，如加权平均数、几何平均值。此外，可能需要同时对几个字段进行聚合。在本文中，我们将展示使用Java流解决这类问题的简单途径。使用该框架，我们可以快速有效地处理大量数据。

我们假设读者对Java流以及效用收藏家班级。

问题布局

让我们考虑一个简单的例子来展示我们想要解决的问题类型。我们将使它非常通用，这样我们就可以很容易地泛化它。让我们考虑一下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.groupingBy接受两个参数：一个分类器函数来进行分组，一个收集器对属于给定组的所有元素进行下游聚合。我们用TaxEntry::getCity作为分类器的功能。对于下游，我们使用Collectors::summingInt返回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包含每个州市的记录。下游收集器和以前一样。

注：为了简洁起见，在代码示例中，我们将假设针对收集器类的所有方法进行静态导入，因此我们不必显示它们的类限定。

事情开始变得更复杂的地方是如果我们想同时做几个聚合。例如，查找给定州和城市的条目数和平均价格之和。库不能提供这个问题的简单解决方案。

为了开始解决这个问题，我们从以前的聚合中获得了一个线索，并定义了一个包含所有需要聚合的字段的记录：

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助手类进行的聚合类型上。它们的方法，包括求和*、平均值*和总结*，只支持整数、长和双本地类型。如果我们有更复杂的类型，比如BigInteger或BigDecimal? 

将侮辱加到伤害中，总结*方法只提供汇总统计数据，包括：最小、最大、计数、和。如果我们想要执行更复杂的计算，如加权平均数或几何平均？

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

复多重聚类：一条解析路径

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

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
}

首先，我们询问如何对每个不同的州-城市对，我们可以找到条目的总数和乘积的总和。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::toMap(第2行)接受三个参数，我们执行以下实现：

• 第一个参数是一个lambda表达式，用于生成映射的键。此函数创建StateCityGroup作为地图的钥匙。这将按州和城市对元素进行分组(第2行)。
• 第二个参数产生映射的值。在我们的例子中，我们创建了一个RatePriceAggregation初始化，计数为1和比率和价格的乘积(第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∑(Rate*Price)。

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

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是Javarecord，它是不可变的，因此可以使用流收集器库提供的支持来并行化计算。

结语

我们已经展示了一些策略来进行复杂的多字段分组，其中包含具有多个和交叉域计算的非原始数据类型。这是一个使用Java流和收集器API的记录列表，因此它为我们提供了快速高效地处理大量数据的能力。