Я согласен с Федерико , что Collector кажется лучшим выбором здесь.
Однако вместо реализации очень специализированной Collector я предпочитаю реализовать только некоторые общие "строительные блоки", а затем использовать эти блоки для compose 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);
Вот как я сочиняю прецедент Collector s:
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: это самый интересный один:
- требуется два
Collector с (оба работают на 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);
}
}
}