com.landawn.abacus.util.stream.Collectors Maven / Gradle / Ivy

* This collector produces stable result for ordered stream: if several * minimal or maximal elements appear, the collector always selects the * first encountered. * *

* If there are no input elements, the finisher method is not called and * empty {@code Optional} is returned. Otherwise the finisher result is * wrapped into {@code Optional}. * * @param the type of the input elements * @param the type of the result wrapped into {@code Optional} * @param comparator comparator which is used to find minimal and maximal * element * @param finisher a {@link BiFunction} which takes minimal and maximal * element and produces the final result. * @return a {@code Collector} which finds minimal and maximal elements. */ public static Collector> minMax(final Comparator comparator, final BiFunction finisher) { final BiFunction, Optional, Optional> finisher2 = new BiFunction, Optional, Optional>() { @Override public Optional apply(Optional min, Optional max) { return min.isPresent() ? Optional.of((R) finisher.apply(min.get(), max.get())) : Optional. empty(); } }; return combine(Collectors.minBy(comparator), Collectors.maxBy(comparator), finisher2); } /** * It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified. *
* * Returns a {@code Collector} which finds all the elements which are equal * to each other and bigger than any other element according to the natural * order. The found elements are collected to {@link List}. * * @param the type of the input elements * @return a {@code Collector} which finds all the maximal elements and * collects them to the {@code List}. * @see #maxAll(Comparator) * @see #maxAll(Collector) */ @SuppressWarnings("rawtypes") public static Collector> maxAll() { return maxAll(Fn.naturalOrder()); } /** * It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified. *
* * Returns a {@code Collector} which finds all the elements which are equal * to each other and bigger than any other element according to the * specified {@link Comparator}. The found elements are collected to * {@link List}. * * @param the type of the input elements * @param comparator a {@code Comparator} to compare the elements * @return a {@code Collector} which finds all the maximal elements and * collects them to the {@code List}. * @see #maxAll(Comparator, Collector) * @see #maxAll() */ public static Collector> maxAll(Comparator comparator) { return maxAll(comparator, Integer.MAX_VALUE); } /** * * @param comparator * @param atMostSize * @return */ public static Collector> maxAll(final Comparator comparator, final int atMostSize) { final Supplier>> supplier = new Supplier>>() { @Override public Pair> get() { final List list = new ArrayList(Math.min(16, atMostSize)); return Pair.of((T) NONE, list); } }; final BiConsumer>, T> accumulator = new BiConsumer>, T>() { @Override public void accept(Pair> a, T t) { if (a.left == NONE) { a.left = t; if (a.right.size() < atMostSize) { a.right.add(t); } } else { int cmp = comparator.compare(t, a.left); if (cmp > 0) { a.left = t; a.right.clear(); } if (cmp >= 0) { if (a.right.size() < atMostSize) { a.right.add(t); } } } } }; final BinaryOperator>> combiner = new BinaryOperator>>() { @Override public Pair> apply(Pair> a, Pair> b) { if (b.left == NONE) { return a; } else if (a.left == NONE) { return b; } int cmp = comparator.compare(a.left, b.left); if (cmp > 0) { return a; } else if (cmp < 0) { return b; } if (a.right.size() < atMostSize) { if (b.right.size() <= atMostSize - a.right.size()) { a.right.addAll(b.right); } else { a.right.addAll(b.right.subList(0, atMostSize - a.right.size())); } } return a; } }; final Function>, List> finisher = new Function>, List>() { @Override public List apply(Pair> a) { return a.right; } }; return new CollectorImpl<>(supplier, accumulator, combiner, finisher, CH_UNORDERED_NOID); } /** * Use occurrences to save the count of largest objects if {@code areAllLargestSame = true}(e.g. {@code Number/String/...}) and return a list by repeat the largest object {@code n} times. * * @param areAllLargestSame * @return * @see Collectors#maxAll(Comparator, int, boolean) */ @SuppressWarnings("rawtypes") public static Collector> maxAll(final boolean areAllLargestSame) { return maxAll(Integer.MAX_VALUE, areAllLargestSame); } /** * Use occurrences to save the count of largest objects if {@code areAllLargestSame = true}(e.g. {@code Number/String/...}) and return a list by repeat the largest object {@code n} times. * * @param atMostSize * @param areAllLargestSame * @return * @see Collectors#maxAll(Comparator, int, boolean) */ @SuppressWarnings("rawtypes") public static Collector> maxAll(final int atMostSize, final boolean areAllLargestSame) { return maxAll(Fn.naturalOrder(), atMostSize, areAllLargestSame); } /** * Use occurrences to save the count of largest objects if {@code areAllLargestSame = true}(e.g. {@code Number/String/...}) and return a list by repeat the largest object {@code n} times. * * @implSpec * The default implementation is equivalent to, for this {@code map}: *

 
     * 
     * if (areAllLargestSame) {
     *     final Function, Integer>, List> finisher = new Function, Integer>, List>() {
     *        @Override
     *        public List apply(Pair, Integer> t) {
     *            int n = N.min(atMostSize, t.right.intValue());
     *            return n == 0 ? new ArrayList() : N.repeat(t.left.get(), n);
     *        }
     *     };
     *
     *     return maxAlll(comparator, countingInt(), finisher);
     * } else {
     *     return maxAll(comparator, atMostSize);
     * }
     * 
     *