如何使用 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;