如何使用 JAVA 流从对象列表中查找平均值

Question

我有两个类 Bill 和 Charge 如下。

class Bill {

    private String id;
    private List<Charge> charges; 
    // Getters Setters Constructors etc..

}

class Charge{

    private String typeId;
    private double a;
    private double b;
    // Getters Setters Constructors etc..
}

List<Bill> bills  = new ArrayList<>();

Bill b1 = new Bill();
b1.setId("1");
List<Charge> charges = new ArrayList<>();
charges.add(new Charge("type-1",20,30));
charges.add(new Charge("type-2",30,30));
b1.setCharges(charges);

Bill b2 = new Bill();
b2.setId("2");
List<Charge> charges2 = new ArrayList<>();
charges2.add(new Charge("type-1",30,40));
charges2.add(new Charge("type-2",40,40));
b2.setCharges(charges2);

现在我有一个方法，这个方法应该基于 typeId 平均 Charges 并且每个 typeId 只返回一个 Charge

public Bill average(List<Bill> bills){
...
}

我希望这种方法返回如下账单

Bill{
    id:null,
    charges:[
        {
            typeId:"type-1",
            a:25,
            b:35
        },
        {
            typeId:"type-2",
            a:35,
            b:35
        }
    ]
}

这可以使用 for 或 forEach 循环来实现，但我希望解决这个 Streams api

Answer 1

这应该可以工作，虽然它看起来不太漂亮：

public Bill average(List<Bill> bills) {
    List<Charge> avgCharges = bills.stream().flatMap(b -> b.getCharges().stream())
        .collect(Collectors.groupingBy(Charge::getTypeId))
        .entrySet().stream()
        .collect(Collectors.toMap(x -> {
            double avgA = x.getValue().stream().mapToDouble(Charge::getA).average().getAsDouble();
            double avgB = x.getValue().stream().mapToDouble(Charge::getB).average().getAsDouble();
            return new Charge(x.getKey(), avgA, avgB);
        }, Map.Entry::getValue))
        .keySet().stream().collect(Collectors.toList());

    return new Bill("avgCharges", avgCharges);
}

测试片段：

Bill avg = average(Arrays.asList(b1, b2));

avg.getCharges().stream()
.forEach(c -> System.out.println(c.getTypeId() + "-> a=" + c.getA() + ", b=" + c.getB()));

提供以下output：

type-1-> a=25.0, b=35.0
type-2-> a=35.0, b=35.0

Answer 2

public static Bill average(List<Bill> bills) {
    final List<Charge> charges = bills.stream()
            .flatMap(x -> x.getCharges().stream())
            .collect(Collectors.collectingAndThen(
                    Collectors.groupingBy(
                            Charge::getTypeId,
                            billInfoToAverage()
                    ),
                    x -> new ArrayList<>(x.values())
            ));
    return new Bill(null, charges);
}


public static Collector<Charge, BillInfoAccumulator, Charge> billInfoToAverage() {
    return Collector.of(
            BillInfoAccumulator::new,
            BillInfoAccumulator::add,
            BillInfoAccumulator::combine,
            BillInfoAccumulator::average
    );
}


class BillInfoAccumulator {
    private String typeId;
    private final DoubleSummaryStatistics aStats = new DoubleSummaryStatistics();
    private final DoubleSummaryStatistics bStats = new DoubleSummaryStatistics();

    public void add(Charge charge) {
        typeId = charge.getTypeId();
        aStats.accept(charge.getA());
        bStats.accept(charge.getB());
    }

    public BillInfoAccumulator combine(BillInfoAccumulator accumulator) {
        aStats.combine(accumulator.aStats);
        bStats.combine(accumulator.bStats);
        return this;
    }

    public Charge average() {
        return new Charge(typeId, aStats.getAverage(), bStats.getAverage());
    }
}

Answer 3

public Bill average(List<Bill> bills) {
    final List<Charge> charges = bills.stream()
            .flatMap(x -> x.getCharges().stream())
            .collect(Collectors.groupingBy(Charge::getTypeId))
            .entrySet().stream()
            .map(x -> new Charge(
                    x.getKey(),
                    x.getValue().stream().mapToDouble(Charge::getA).average().getAsDouble(),
                    x.getValue().stream().mapToDouble(Charge::getB).average().getAsDouble()))
            .collect(Collectors.toList());
    return new Bill(null, charges);
}

或者

public Bill average(List<Bill> bills) {
    return bills.stream()
            .flatMap(x -> x.getCharges().stream())
            .collect(Collectors.collectingAndThen(Collectors.groupingBy(Charge::getTypeId),
                    x -> {
                        final List<Charge> charges = x.entrySet().stream()
                                .map(y -> new Charge(
                                        y.getKey(),
                                        y.getValue().stream().mapToDouble(Charge::getA).average().getAsDouble(),
                                        y.getValue().stream().mapToDouble(Charge::getB).average().getAsDouble()))
                                .collect(Collectors.toList());
                        return new Bill(null, charges);
                    }));
}

Answer 4

一个非常天真和简单的解决方案。 当然，操作的数量可以减少到一半，但这使得它更容易理解。

1. 根据类型从每个账单中收取费用。 由于每个账单都有费用列表，我们需要使用flatMap来提取费用并将它们全部收集到一个列表中，然后按类型filter 。
2. 根据类型查找 a 和 b 的平均值

3. 创建一个新的比尔 object 并返回相同

    List<Charge> t1Charges = bills.stream().flatMap(b -> b.charges.stream()).filter(c -> c.typeId == "type-1").collect(Collectors.toList()); List<Charge> t2Charges = bills.stream().flatMap(b -> b.charges.stream()).filter(c -> c.typeId == "type-2").collect(Collectors.toList()); Double t1a = t1Charges.stream().mapToDouble(x -> xa).average().getAsDouble(); Double t1b = t1Charges.stream().mapToDouble(x -> xb).average().getAsDouble(); final Double t2a = t2Charges.stream().mapToDouble(x -> xa).average().getAsDouble(); final Double t2b = t2Charges.stream().mapToDouble(x -> xb).average().getAsDouble(); final Bill av = new Bill(); av.charges.add(new Charge("type-1",t1a,t1b)); av.charges.add(new Charge("type-2",t2a,t2b)); return av;