org.agzamovr.collectors.SummingIntCollector Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of collectorex Show documentation
Java Collectors extensions for using with Java 8 streams
The newest version!
package org.agzamovr.collectors;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import java.util.stream.Collector;

import static java.util.Comparator.nullsLast;
import static java.util.stream.Collectors.toList;

class SummingIntCollector {
    static final SummingIntCollector SUMMING_INT_COLLECTOR = new SummingIntCollector();

    private void validateInput(ToIntFunction mapper,
                               Comparator comparator,
                               Collector downstream) {
        Objects.requireNonNull(mapper, "Mapper cannot be null");
        Objects.requireNonNull(comparator, "Comparator cannot be null");
        Objects.requireNonNull(downstream, "Downstream collector cannot be null");
    }

     R summingIntFinisher(ToIntFunction mapper,
                                   Comparator comparator,
                                   List list,
                                   Collector downstream) {
        validateInput(mapper, comparator, downstream);
        list.sort(comparator);
        int sum = 0;
        Supplier downstreamSupplier = downstream.supplier();
        Function finisher = downstream.finisher();
        BiConsumer downstreamAccumulator = downstream.accumulator();
        A container = downstreamSupplier.get();
        for (T item : list) {
            sum = sum + mapper.applyAsInt(item);
            downstreamAccumulator.accept(container, sum);
        }
        return finisher.apply(container);
    }

    >
    Collector> summingInt(ToIntFunction mapper) {
        return summingInt(mapper, nullsLast(Comparator.naturalOrder()));
    }

    , R>
    Collector summingInt(ToIntFunction mapper,
                                  Collector downstream) {
        return summingInt(mapper, nullsLast(Comparator.naturalOrder()), downstream);
    }

    
    Collector> summingInt(ToIntFunction mapper,
                                              Comparator comparator) {
        return summingInt(mapper, comparator, toList());
    }

    
    Collector, R> summingInt(ToIntFunction mapper,
                                        Comparator comparator,
                                        Collector downstream) {
        return Collector.of(ArrayList::new,
                List::add,
                CollectorEx::listCombiner,
                (list) -> summingIntFinisher(mapper, comparator, list, downstream));
    }
}
Related Artifacts