我同意Federico 的观点，Collector 似乎是这里的最佳选择。
然而，与其实现一个非常专业的Collector，我更愿意实现一些通用的“构建块”，然后使用这些块来撰写在给定情况下我需要的Collector。
假设：
interface Mapper<T> {
T map(Dummy dummy, Class<T> type);
}
这是使用我的解决方案时DummyObject 的构造方式：
Collector<Dummy, ?, DummyObject> dummyObjectCollector = someCondition
? toDummyObjectWithSums(mapper)
: toDummyObjectWithoutSums(mapper);
return dummy.stream().collect(dummyObjectCollector);
这是我如何编写特定于用例的Collectors：
private static Collector<Dummy, ?, DummyObject> toDummyObjectWithoutSums(Mapper<NewDummy> mapper) {
return Collectors.collectingAndThen(toNewDummyList(mapper), DummyObject::new);
}
private static Collector<Dummy, ?, List<NewDummy>> toNewDummyList(Mapper<NewDummy> mapper) {
return Collectors.mapping(dummy -> mapper.map(dummy, NewDummy.class), Collectors.toList());
}
private static Collector<Dummy, ?, DummyObject> toDummyObjectWithSums(Mapper<NewDummy> mapper) {
return ExtraCollectors.collectingBoth(
toNewDummyList(mapper),
sumGroupCollector(),
(newDummyList, amountSumPair) -> new DummyObject(
newDummyList, amountSumPair.getAmountSum1(), amountSumPair.getAmountSum2()
)
);
}
private static Collector<Dummy, ?, AmountSumPair> sumGroupCollector() {
return ExtraCollectors.collectingBoth(
summingAmount(Dummy::getAmount1),
summingAmount(Dummy::getAmount2),
AmountSumPair::new
);
}
static Collector<Dummy, ?, BigDecimal> summingAmount(Function<Dummy, BigDecimal> getter) {
return Collectors.mapping(getter,
ExtraCollectors.filtering(Objects::nonNull,
ExtraCollectors.summingBigDecimal()
)
);
}
private static class AmountSumPair {
private final BigDecimal amountSum1;
private final BigDecimal amountSum2;
// constructor + getters
}
最后，我们来看看通用的“积木”（我把它放在ExtraCollectors 类中）：
-
summingBigDecimal：很明显
-
filtering：也比较明显（对应Stream.filter）
-
collectingBoth：这是最有趣的一个：
- 需要两个
Collectors（都在T上运行，但返回不同的结果，即Collector<T, ?, R1>和Collector<T, ?, R2>）
- 并使用
BiFunction<R1, R2, R> 将它们组合成一个Collector<T, ?, R>
这是ExtraCollectors 类：
final class ExtraCollectors {
static Collector<BigDecimal, ?, BigDecimal> summingBigDecimal() {
return Collectors.reducing(BigDecimal.ZERO, BigDecimal::add);
}
static <T, A, R> Collector<T, A, R> filtering(
Predicate<T> filter, Collector<T, A, R> downstream) {
return Collector.of(
downstream.supplier(),
(A acc, T t) -> {
if (filter.test(t)) {
downstream.accumulator().accept(acc, t);
}
},
downstream.combiner(),
downstream.finisher(),
downstream.characteristics().toArray(new Collector.Characteristics[0])
);
}
static <T, R1, R2, R> Collector<T, ?, R> collectingBoth(
Collector<T, ?, R1> collector1, Collector<T, ?, R2> collector2, BiFunction<R1, R2, R> biFinisher) {
return collectingBoth(new BiCollectorHandler<>(collector1, collector2), biFinisher);
}
// method needed to capture A1 and A2
private static <T, A1, R1, A2, R2, R> Collector<T, ?, R> collectingBoth(
BiCollectorHandler<T, A1, R1, A2, R2> biCollectorHandler, BiFunction<R1, R2, R> biFinisher) {
return Collector.<T, BiCollectorHandler<T, A1, R1, A2, R2>.BiAccumulator, R>of(
biCollectorHandler::newBiAccumulator,
BiCollectorHandler.BiAccumulator::accept,
BiCollectorHandler.BiAccumulator::combine,
biAccumulator -> biAccumulator.finish(biFinisher)
);
}
}
这里是BiCollectorHandler 类（ExtraCollectors.collectingBoth 内部使用）：
final class BiCollectorHandler<T, A1, R1, A2, R2> {
private final Collector<T, A1, R1> collector1;
private final Collector<T, A2, R2> collector2;
BiCollectorHandler(Collector<T, A1, R1> collector1, Collector<T, A2, R2> collector2) {
this.collector1 = collector1;
this.collector2 = collector2;
}
BiAccumulator newBiAccumulator() {
return new BiAccumulator(collector1.supplier().get(), collector2.supplier().get());
}
final class BiAccumulator {
final A1 acc1;
final A2 acc2;
private BiAccumulator(A1 acc1, A2 acc2) {
this.acc1 = acc1;
this.acc2 = acc2;
}
void accept(T t) {
collector1.accumulator().accept(acc1, t);
collector2.accumulator().accept(acc2, t);
}
BiAccumulator combine(BiAccumulator other) {
A1 combined1 = collector1.combiner().apply(acc1, other.acc1);
A2 combined2 = collector2.combiner().apply(acc2, other.acc2);
return new BiAccumulator(combined1, combined2);
}
<R> R finish(BiFunction<R1, R2, R> biFinisher) {
R1 result1 = collector1.finisher().apply(acc1);
R2 result2 = collector2.finisher().apply(acc2);
return biFinisher.apply(result1, result2);
}
}
}