使用 Java 8 条流映射、聚合和组合总计

Question

我正在尝试重新创建一个进程来创建一个对象列表，这些对象列表是使用 Java 8 个流的另一个对象列表的聚合。

例如，我有一个 class，如下所述，它是通过数据库调用或类似方式提供的

public class Order {

    private String orderNumber;        
    private String customerNumber;
    private String customerGroup;
    private Date deliveryDate;
    private double orderValue;
    private double orderQty;
}

在我的应用程序的其他地方，我有一个 class OrderTotal，它表示按客户编号和组进行的订单分组和汇总，以及对 orderValue 和 orderQty 的总和的汇总。（在 customerGroup 和 customerNumber 上有一个 equals 和 hashcode）

public class OrderTotal {

    private String customerGroup;
    private String customerNumber;
    private double totalValue;
    private double totalQty;
}

我们在 java 8 之前实现此目的的 'long hand' 方式如下

public Collection<OrderTotal> getTotals(List<Order> orders) {
    ///map created for quick access to the order total for each order 
    Map<OrderTotal, OrderTotal> map = new HashMap<>();
    ///loop through all orders adding to the relevaent order total per iteration
    for (Order order : orders) {
        OrderTotal orderTotal = createFromOrder(order);
        {
            ///if the order total already exists in the map use that one, otherwise add it to the map.
            OrderTotal temp = map.get(orderTotal);
            if(temp == null){
                map.put(orderTotal, orderTotal);
            }else{
                orderTotal = temp;
            }
        }
        ///add the values to the total 
        aggregate(orderTotal, order);
    }        
    return map.values();
}

private OrderTotal createFromOrder(Order order) {
    OrderTotal orderTotal = new OrderTotal();
    orderTotal.setCustomerGroup(order.getCustomerGroup());
    orderTotal.setCustomerNumber(order.getCustomerNumber());
    return orderTotal;
}

private void aggregate(OrderTotal orderTotal, Order order){
    orderTotal.setTotalQty(orderTotal.getTotalQty() + order.getOrderQty());
    orderTotal.setTotalValue(orderTotal.getTotalValue() + order.getOrderValue());
}

我一直在研究使用分组依据和归约函数的收集器，但它们似乎都专注于聚合订单 class 而不是在 OrderTotal class.

中组合总数

我正在寻找一个 tidy stream 或 collect 函数来消除此代码中的所有膨胀。

Answer 1

你可以这样做 -

Double totalQtyAgg =  orders.stream()
                            .map(x -> createFromOrder(x))
                            .mapToDouble(x -> x.totalQty)
                            .sum();
Double totalValueAgg = orders.stream()
                             .map(x -> createFromOrder(x))
                             .mapToDouble(x -> x.totalValue)
                             .sum();

Answer 2

您可以按如下方式使用 toMap 收集器：

Collection<OrderTotal> result = orders.stream()
            .map(o -> createFromOrder(o))
            .collect(toMap(Function.identity(),
                        Function.identity(),
                        (l, r) -> {
                            aggregate(l, r);
                            return l;
                        }))
                .values();

请注意，这需要将 aggregate 方法参数更改为 aggregate(OrderTotal orderTotal, OrderTotal order){ ... }，即两个参数的类型均为 OrderTotal.

或者您可以完全删除 aggregate 方法并执行 toMap:

中的逻辑

Collection<OrderTotal> result = orders.stream()
            .map(o -> createFromOrder(o))
            .collect(toMap(Function.identity(),
                    Function.identity(),
                    (l, r) -> {
                        l.setTotalQty(l.getTotalQty() + r.getTotalQty());
                        l.setTotalValue(l.getTotalValue() + r.getTotalValue());
                        return l;
                    }))
            .values();

使用 Java 8 条流映射、聚合和组合总计

Mapping, aggregating and composing totals using Java 8 Streams

java

composition

aggregation

java-8

java-stream