I agree with Federico that a Collector seems the best choice here.
However, instead of implementing a very specialized Collector, I prefer to implement only some generic "building blocks", and then use those blocks to compose the Collector that I need in a given case.
Assuming:
interface Mapper<T> {
T map(Dummy dummy, Class<T> type);
}
this is how the construction of DummyObject looks like when using my solution:
Collector<Dummy, ?, DummyObject> dummyObjectCollector = someCondition
? toDummyObjectWithSums(mapper)
: toDummyObjectWithoutSums(mapper);
return dummy.stream().collect(dummyObjectCollector);
Here is how I compose the use-case-specific 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
}
Finally, we come to the generic "building blocks" (which I placed inside ExtraCollectors class):
summingBigDecimal: quite obviousfiltering: also rather obvious (corresponds to Stream.filter)collectingBoth: this is the most interesting one:
- it takes two
Collectors (both operating on T but returning different results, i.e. Collector<T, ?, R1> and Collector<T, ?, R2>)
- and it combines them using a
BiFunction<R1, R2, R> into a single Collector<T, ?, R>
Here is the ExtraCollectors class:
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)
);
}
}
And here is the BiCollectorHandler class (used internally by 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);
}
}
}
