Uses of Interface
com.landawn.abacus.util.stream.Collector

Packages that use Collector

Package	Description
com.landawn.abacus.util
com.landawn.abacus.util.stream

Uses of Collector in com.landawn.abacus.util

Methods in com.landawn.abacus.util that return Collector

Modifier and Type	Method	Description
static <T, A, R> Collector<T,A,R>	Fn.from(Collector<T,A,R> collector)

Methods in com.landawn.abacus.util with parameters of type Collector

Modifier and Type	Method	Description
<R, A> ExceptionalStream<R,E>	ExceptionalStream.collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Collector<? super T,A,R> collector)
<R, A> ExceptionalStream<R,E>	ExceptionalStream.collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible, Collector<? super T,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
<R, A> R	ExceptionalStream.collect(Collector<? super T,A,R> collector)
<R, RR, A, E2 extends Exception> RR	ExceptionalStream.collectAndThen(Collector<? super T,A,R> collector, Throwables.Function<? super R,? extends RR,E2> func)	Collect and then.
<K, A, D> ExceptionalStream<Map.Entry<K,D>,E>	ExceptionalStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,A,D> downstream)
<K, A, D> ExceptionalStream<Map.Entry<K,D>,E>	ExceptionalStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
<K, V, A, D> ExceptionalStream<Map.Entry<K,D>,E>	ExceptionalStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper, Collector<? super V,A,D> downstream)
<K, V, A, D> ExceptionalStream<Map.Entry<K,D>,E>	ExceptionalStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
<U, K, A, D, R> ExceptionalStream<R,E>	ExceptionalStream.groupJoin(ExceptionalStream<U,? extends E> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Collector<? super U,A,D> downstream, Throwables.BiFunction<? super T,? super D,R,? extends E> func)	The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<U, K, A, D> ExceptionalStream<Pair<T,D>,E>	ExceptionalStream.groupJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Collector<? super U,A,D> downstream)	The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<U, K, A, D, R> ExceptionalStream<R,E>	ExceptionalStream.groupJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Collector<? super U,A,D> downstream, Throwables.BiFunction<? super T,? super D,R,? extends E> func)	The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<K, A, D, E2 extends Exception> Map<K,D>	ExceptionalStream.groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream)
<K, A, D, M extends Map<K, D>, E2 extends Exception> M	ExceptionalStream.groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
<K, V, A, D, E2 extends Exception, E3 extends Exception> Map<K,D>	ExceptionalStream.groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,A,D> downstream)
<K, V, A, D, M extends Map<K, D>, E2 extends Exception, E3 extends Exception> M	ExceptionalStream.groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends M> mapFactory)
<U, A, D, R> ExceptionalStream<R,E>	ExceptionalStream.joinByRange(ExceptionalStream<U,? extends E> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,D> collector, Throwables.BiFunction<? super T,? super D,R,? extends E> func)
<U, A, D, R> ExceptionalStream<R,E>	ExceptionalStream.joinByRange(ExceptionalStream<U,? extends E> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,D> collector, Throwables.BiFunction<? super T,? super D,R,? extends E> func, Throwables.Function<ExceptionalStream.ExceptionalIterator<U,E>,ExceptionalStream<R,E>,? extends E> mapperForUnJoinedEelements)
<U, A, R> ExceptionalStream<Pair<T,R>,E>	ExceptionalStream.joinByRange(ExceptionalStream<U,? extends E> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,R> collector)
<U, A, D, R> ExceptionalStream<R,E>	ExceptionalStream.joinByRange(Stream<U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,D> collector, Throwables.BiFunction<? super T,? super D,R,? extends E> func)
<U, A, D, R> ExceptionalStream<R,E>	ExceptionalStream.joinByRange(Stream<U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,D> collector, Throwables.BiFunction<? super T,? super D,R,? extends E> func, Throwables.Function<Iterator<U>,ExceptionalStream<R,E>,? extends E> mapperForUnJoinedEelements)
<U, A, R> ExceptionalStream<Pair<T,R>,E>	ExceptionalStream.joinByRange(Stream<U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,R> collector)
<U, A, D, R> ExceptionalStream<R,E>	ExceptionalStream.joinByRange(Iterator<U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,D> collector, Throwables.BiFunction<? super T,? super D,R,? extends E> func)
<U, A, D, R> ExceptionalStream<R,E>	ExceptionalStream.joinByRange(Iterator<U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,D> collector, Throwables.BiFunction<? super T,? super D,R,? extends E> func, Throwables.Function<Iterator<U>,ExceptionalStream<R,E>,? extends E> mapperForUnJoinedEelements)
<U, A, R> ExceptionalStream<Pair<T,R>,E>	ExceptionalStream.joinByRange(Iterator<U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Collector<? super U,A,R> collector)
<A, D> ExceptionalStream<Map.Entry<Boolean,D>,E>	ExceptionalStream.partitionBy(Throwables.Predicate<? super T,E> predicate, Collector<? super T,A,D> downstream)
<A, D, E2 extends Exception> Map<Boolean,D>	ExceptionalStream.partitionTo(Throwables.Predicate<? super T,E2> predicate, Collector<? super T,A,D> downstream)
<A, R> ExceptionalStream<R,E>	ExceptionalStream.sliding(int windowSize, int increment, Collector<? super T,A,R> collector)
<R, A> ExceptionalStream<R,E>	ExceptionalStream.split(int chunkSize, Collector<? super T,A,R> collector)
final <K, A, D, E2 extends Exception> Map<K,D>	ExceptionalStream.toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream)	Deprecated. replaced by groupTo
final <K, A, D, M extends Map<K, D>, E2 extends Exception> M	ExceptionalStream.toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)	Deprecated. replaced by groupTo
final <K, V, A, D, E2 extends Exception, E3 extends Exception> Map<K,D>	ExceptionalStream.toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,A,D> downstream)	Deprecated. replaced by groupTo
final <K, V, A, D, M extends Map<K, D>, E2 extends Exception, E3 extends Exception> M	ExceptionalStream.toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends M> mapFactory)	Deprecated. replaced by groupTo
<A, R> ExceptionalStream<R,E>	ExceptionalStream.window(int maxWindowSize, Duration maxDuration, LongSupplier startTime, Collector<? super T,A,R> collector)
<A, R> ExceptionalStream<R,E>	ExceptionalStream.window(int maxWindowSize, Duration maxDuration, Collector<? super T,A,R> collector)
<A, R> ExceptionalStream<R,E>	ExceptionalStream.window(Duration duration, long incrementInMillis, LongSupplier startTime, Collector<? super T,A,R> collector)
<A, R> ExceptionalStream<R,E>	ExceptionalStream.window(Duration duration, long incrementInMillis, Collector<? super T,A,R> collector)
<A, R> ExceptionalStream<R,E>	ExceptionalStream.window(Duration duration, LongSupplier startTime, Collector<? super T,A,R> collector)
<A, R> ExceptionalStream<R,E>	ExceptionalStream.window(Duration duration, Collector<? super T,A,R> collector)
static <T, A, R> Function<Stream<Timed<T>>,Stream<R>>	Fn.window(int maxWindowSize, Duration maxDuration, LongSupplier startTime, Collector<? super Timed<T>,A,R> collector)	Split this stream at where maxWindowSize or maxDuration reaches first.
static <T, A, R> Function<Stream<Timed<T>>,Stream<R>>	Fn.window(Duration duration, long incrementInMillis, LongSupplier startTime, Collector<? super Timed<T>,A,R> collector)
static <T, A, R> Function<Stream<Timed<T>>,Stream<R>>	Fn.window(Duration duration, LongSupplier startTime, Collector<? super Timed<T>,A,R> collector)

Uses of Collector in com.landawn.abacus.util.stream

Methods in com.landawn.abacus.util.stream that return Collector

Modifier and Type	Method	Description
static <T> Collector<T,?,u.Optional<BigDecimal>>	Collectors.averagingBigDecimal(Function<? super T,BigDecimal> mapper)
static <T> Collector<T,?,BigDecimal>	Collectors.averagingBigDecimalOrThrow(Function<? super T,BigDecimal> mapper)
static <T> Collector<T,?,u.Optional<BigDecimal>>	Collectors.averagingBigInteger(Function<? super T,BigInteger> mapper)
static <T> Collector<T,?,BigDecimal>	Collectors.averagingBigIntegerOrThrow(Function<? super T,BigInteger> mapper)
static <T> Collector<T,?,u.OptionalDouble>	Collectors.averagingDouble(ToDoubleFunction<? super T> mapper)
static <T> Collector<T,?,Double>	Collectors.averagingDoubleOrThrow(ToDoubleFunction<? super T> mapper)
static <T> Collector<T,?,u.OptionalDouble>	Collectors.averagingInt(ToIntFunction<? super T> mapper)
static <T> Collector<T,?,Double>	Collectors.averagingIntOrThrow(ToIntFunction<? super T> mapper)
static <T> Collector<T,?,u.OptionalDouble>	Collectors.averagingLong(ToLongFunction<? super T> mapper)
static <T> Collector<T,?,Double>	Collectors.averagingLongOrThrow(ToLongFunction<? super T> mapper)
static <T, A, R, RR> Collector<T,A,RR>	Collectors.collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
static <T, A, R, RR> Collector<T,A,RR>	Collectors.collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
static <T, A1, A2, R1, R2> Collector<T,Tuple.Tuple2<A1,A2>,Tuple.Tuple2<R1,R2>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2)
static <T, A1, A2, R1, R2, R> Collector<T,Tuple.Tuple2<A1,A2>,R>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, BiFunction<? super R1,? super R2,R> finisher)
static <T, A1, A2, A3, R1, R2, R3> Collector<T,Tuple.Tuple3<A1,A2,A3>,Tuple.Tuple3<R1,R2,R3>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3)
static <T, A1, A2, A3, R1, R2, R3, R> Collector<T,Tuple.Tuple3<A1,A2,A3>,R>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, TriFunction<? super R1,? super R2,? super R3,R> finisher)
static <T, A1, A2, A3, A4, R1, R2, R3, R4> Collector<T,Tuple.Tuple4<A1,A2,A3,A4>,Tuple.Tuple4<R1,R2,R3,R4>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, Collector<? super T,A4,R4> collector4)
static <T, A1, A2, A3, A4, A5, R1, R2, R3, R4, R5> Collector<T,Tuple.Tuple5<A1,A2,A3,A4,A5>,Tuple.Tuple5<R1,R2,R3,R4,R5>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, Collector<? super T,A4,R4> collector4, Collector<? super T,A5,R5> collector5)
static <T> Collector<T,?,List<?>>	Collectors.combine(Collection<? extends Collector<? super T,?,?>> collectors)
static <T> Collector<T,?,List<?>>	Collectors.combine(List<? extends Collector<? super T,?,?>> collectors)
static <T, A1, A2, R1, R2> Collector<T,Tuple.Tuple2<A1,A2>,Tuple.Tuple2<R1,R2>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2)
static <T, A1, A2, R1, R2, R> Collector<T,Tuple.Tuple2<A1,A2>,R>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, BiFunction<? super R1,? super R2,R> finisher)
static <T, A1, A2, A3, R1, R2, R3> Collector<T,Tuple.Tuple3<A1,A2,A3>,Tuple.Tuple3<R1,R2,R3>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3)
static <T, A1, A2, A3, R1, R2, R3, R> Collector<T,Tuple.Tuple3<A1,A2,A3>,R>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, TriFunction<? super R1,? super R2,? super R3,R> finisher)
static <T, A1, A2, A3, A4, R1, R2, R3, R4> Collector<T,Tuple.Tuple4<A1,A2,A3,A4>,Tuple.Tuple4<R1,R2,R3,R4>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, Collector<? super T,A4,R4> collector4)
static <T, A1, A2, A3, A4, A5, R1, R2, R3, R4, R5> Collector<T,Tuple.Tuple5<A1,A2,A3,A4,A5>,Tuple.Tuple5<R1,R2,R3,R4,R5>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, Collector<? super T,A4,R4> collector4, Collector<? super T,A5,R5> collector5)
static Collector<CharSequence,?,String>	Collectors.commonPrefix()	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static Collector<CharSequence,?,String>	Collectors.commonSuffix()	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T> Collector<T,?,Long>	Collectors.counting()
static <T, K> Collector<T,?,Map<K,Long>>	Collectors.countingBy(Function<? super T,? extends K> keyMapper)
static <T, K, M extends Map<K, Long>> Collector<T,?,M>	Collectors.countingBy(Function<? super T,? extends K> keyMapper, Supplier<? extends M> mapFactory)
static <T> Collector<T,?,Integer>	Collectors.countingInt()
static <T, K> Collector<T,?,Map<K,Integer>>	Collectors.countingIntBy(Function<? super T,? extends K> keyMapper)
static <T, K, M extends Map<K, Integer>> Collector<T,?,M>	Collectors.countingIntBy(Function<? super T,? extends K> keyMapper, Supplier<? extends M> mapFactory)
static <T> Collector<T,?,List<T>>	Collectors.distinctBy(Function<? super T,?> keyExtractor)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T, C extends Collection<T>> Collector<T,?,C>	Collectors.distinctBy(Function<? super T,?> keyExtractor, Supplier<? extends C> suppplier)
static <T> Collector<T,?,Integer>	Collectors.distinctCount(Function<? super T,?> keyExtractor)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T> Collector<T,?,List<T>>	Collectors.filtering(Predicate<? super T> predicate)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T, A, R> Collector<T,?,R>	Collectors.filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T> Collector<T,?,u.Optional<T>>	Collectors.first()	Only works for sequential Stream.
static <T> Collector<T,?,List<T>>	Collectors.first(int n)	Only works for sequential Stream.
static <T, T2, U> Collector<T,?,List<U>>	Collectors.flatMapping(Function<? super T,? extends Stream<? extends T2>> flatMapper, BiFunction<? super T,? super T2,? extends U> mapper)
static <T, T2, U, A, R> Collector<T,?,R>	Collectors.flatMapping(Function<? super T,? extends Stream<? extends T2>> flatMapper, BiFunction<? super T,? super T2,? extends U> mapper, Collector<? super U,A,R> downstream)
static <T, U> Collector<T,?,List<U>>	Collectors.flatMapping(Function<? super T,? extends Stream<? extends U>> mapper)
static <T, U, A, R> Collector<T,?,R>	Collectors.flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)
static <T, K, V> Collector<T,?,ListMultimap<K,V>>	Collectors.flatMappingKeyToMultimap(Function<? super T,Stream<? extends K>> flatKeyMapper, Function<? super T,V> valueMapper)
static <T, K, V, C extends Collection<V>, M extends Multimap<K, V, C>> Collector<T,?,M>	Collectors.flatMappingKeyToMultimap(Function<? super T,Stream<? extends K>> flatKeyMapper, Function<? super T,V> valueMapper, Supplier<? extends M> mapFactory)
static <T, K, V> Collector<T,?,ListMultimap<K,V>>	Collectors.flatMappingValueToMultimap(Function<? super T,K> keyMapper, Function<? super T,? extends Stream<? extends V>> flatValueMapper)
static <T, K, V, C extends Collection<V>, M extends Multimap<K, V, C>> Collector<T,?,M>	Collectors.flatMappingValueToMultimap(Function<? super T,K> keyMapper, Function<? super T,? extends Stream<? extends V>> flatValueMapper, Supplier<? extends M> mapFactory)
static <T, T2, U> Collector<T,?,List<U>>	Collectors.flattMapping(Function<? super T,? extends Collection<? extends T2>> flatMapper, BiFunction<? super T,? super T2,? extends U> mapper)
static <T, T2, U, A, R> Collector<T,?,R>	Collectors.flattMapping(Function<? super T,? extends Collection<? extends T2>> flatMapper, BiFunction<? super T,? super T2,? extends U> mapper, Collector<? super U,A,R> downstream)
static <T, U> Collector<T,?,List<U>>	Collectors.flattMapping(Function<? super T,? extends Collection<? extends U>> mapper)
static <T, U, A, R> Collector<T,?,R>	Collectors.flattMapping(Function<? super T,? extends Collection<? extends U>> mapper, Collector<? super U,A,R> downstream)
static <T, K, V> Collector<T,?,ListMultimap<K,V>>	Collectors.flattMappingKeyToMultimap(Function<? super T,? extends Collection<? extends K>> flatKeyMapper, Function<? super T,V> valueMapper)
static <T, K, V, C extends Collection<V>, M extends Multimap<K, V, C>> Collector<T,?,M>	Collectors.flattMappingKeyToMultimap(Function<? super T,? extends Collection<? extends K>> flatKeyMapper, Function<? super T,V> valueMapper, Supplier<? extends M> mapFactory)
static <T, K, V> Collector<T,?,ListMultimap<K,V>>	Collectors.flattMappingValueToMultimap(Function<? super T,K> keyMapper, Function<? super T,? extends Collection<? extends V>> flatValueMapper)
static <T, K, V, C extends Collection<V>, M extends Multimap<K, V, C>> Collector<T,?,M>	Collectors.flattMappingValueToMultimap(Function<? super T,K> keyMapper, Function<? super T,? extends Collection<? extends V>> flatValueMapper, Supplier<? extends M> mapFactory)
static <T, A, R> Collector<T,A,R>	Collector.from(Collector<T,A,R> collector)
static <T, A, R> Collector<T,A,R>	Collectors.from(Collector<T,A,R> collector)	Save as Collector.from(collector)
static <T, K> Collector<T,?,Map<K,List<T>>>	Collectors.groupingBy(Function<? super T,? extends K> keyMapper)
static <T, K, M extends Map<K, List<T>>> Collector<T,?,M>	Collectors.groupingBy(Function<? super T,? extends K> keyMapper, Supplier<? extends M> mapFactory)
static <T, K, A, D> Collector<T,?,Map<K,D>>	Collectors.groupingBy(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream)
static <T, K, A, D, M extends Map<K, D>> Collector<T,?,M>	Collectors.groupingBy(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
static <T, K> Collector<T,?,ConcurrentMap<K,List<T>>>	Collectors.groupingByConcurrent(Function<? super T,? extends K> keyMapper)
static <T, K, M extends ConcurrentMap<K, List<T>>> Collector<T,?,M>	Collectors.groupingByConcurrent(Function<? super T,? extends K> keyMapper, Supplier<? extends M> mapFactory)
static <T, K, A, D> Collector<T,?,ConcurrentMap<K,D>>	Collectors.groupingByConcurrent(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream)
static <T, K, A, D, M extends ConcurrentMap<K, D>> Collector<T,?,M>	Collectors.groupingByConcurrent(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
static Collector<CharSequence,?,String>	Collectors.joining()
static Collector<CharSequence,?,String>	Collectors.joining(CharSequence delimiter)
static Collector<CharSequence,?,String>	Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
static <T> Collector<T,?,u.Optional<T>>	Collectors.last()	Only works for sequential Stream.
static <T> Collector<T,?,List<T>>	Collectors.last(int n)	Only works for sequential Stream.
static <T, U> Collector<T,?,List<U>>	Collectors.mapping(Function<? super T,? extends U> mapper)
static <T, U, A, R> Collector<T,?,R>	Collectors.mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)
static <T extends Comparable<? super T>> Collector<T,?,u.Optional<T>>	Collectors.max()
static <T> Collector<T,?,u.Optional<T>>	Collectors.max(Comparator<? super T> comparator)
static <T extends Comparable<? super T>> Collector<T,?,List<T>>	Collectors.maxAll()	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T extends Comparable, A, D> Collector<T,?,D>	Collectors.maxAll(Collector<T,A,D> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T> Collector<T,?,List<T>>	Collectors.maxAll(Comparator<? super T> comparator)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T> Collector<T,?,List<T>>	Collectors.maxAll(Comparator<? super T> comparator, int atMostSize)
static <T, A, D> Collector<T,?,D>	Collectors.maxAll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T extends Comparable, A, D> Collector<T,?,u.Optional<Pair<T,D>>>	Collectors.maxAlll(Collector<T,A,D> downstream)
static <T, A, D> Collector<T,?,u.Optional<Pair<T,D>>>	Collectors.maxAlll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream)
static <T, A, D, R> Collector<T,?,R>	Collectors.maxAlll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream, Function<u.Optional<Pair<T,D>>,R> finisher)
static <T> Collector<T,?,u.Optional<T>>	Collectors.maxBy(Function<? super T,? extends Comparable> keyMapper)
static <T> Collector<T,?,T>	Collectors.maxByOrGet(Function<? super T,? extends Comparable> keyMapper, Supplier<? extends T> other)
static <T> Collector<T,?,T>	Collectors.maxByOrThrow(Function<? super T,? extends Comparable> keyMapper)
static <T> Collector<T,?,T>	Collectors.maxByOrThrow(Function<? super T,? extends Comparable> keyMapper, Supplier<? extends RuntimeException> exceptionSupplier)
static <T extends Comparable<? super T>> Collector<T,?,T>	Collectors.maxOrGet(Supplier<? extends T> other)
static <T> Collector<T,?,T>	Collectors.maxOrGet(Comparator<? super T> comparator, Supplier<? extends T> other)
static <T extends Comparable<? super T>> Collector<T,?,T>	Collectors.maxOrThrow()
static <T> Collector<T,?,T>	Collectors.maxOrThrow(Comparator<? super T> comparator)
static <T> Collector<T,?,T>	Collectors.maxOrThrow(Comparator<? super T> comparator, Supplier<? extends RuntimeException> exceptionSupplier)
static <T extends Comparable<? super T>> Collector<T,?,u.Optional<T>>	Collectors.min()
static <T> Collector<T,?,u.Optional<T>>	Collectors.min(Comparator<? super T> comparator)
static <T extends Comparable<? super T>> Collector<T,?,List<T>>	Collectors.minAll()	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T extends Comparable, A, D> Collector<T,?,D>	Collectors.minAll(Collector<T,A,D> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T> Collector<T,?,List<T>>	Collectors.minAll(Comparator<? super T> comparator)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T> Collector<T,?,List<T>>	Collectors.minAll(Comparator<? super T> comparator, int atMostSize)
static <T, A, D> Collector<T,?,D>	Collectors.minAll(Comparator<? super T> comparator, Collector<T,A,D> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T extends Comparable, A, D> Collector<T,?,u.Optional<Pair<T,D>>>	Collectors.minAlll(Collector<T,A,D> downstream)
static <T, A, D> Collector<T,?,u.Optional<Pair<T,D>>>	Collectors.minAlll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream)
static <T, A, D, R> Collector<T,?,R>	Collectors.minAlll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream, Function<u.Optional<Pair<T,D>>,R> finisher)
static <T> Collector<T,?,u.Optional<T>>	Collectors.minBy(Function<? super T,? extends Comparable> keyMapper)
static <T> Collector<T,?,T>	Collectors.minByOrGet(Function<? super T,? extends Comparable> keyMapper, Supplier<? extends T> other)
static <T> Collector<T,?,T>	Collectors.minByOrThrow(Function<? super T,? extends Comparable> keyMapper)
static <T> Collector<T,?,T>	Collectors.minByOrThrow(Function<? super T,? extends Comparable> keyMapper, Supplier<? extends RuntimeException> exceptionSupplier)
static <T extends Comparable> Collector<T,?,u.Optional<Pair<T,T>>>	Collectors.minMax()
static <T> Collector<T,?,u.Optional<Pair<T,T>>>	Collectors.minMax(Comparator<? super T> comparator)
static <T, R> Collector<T,?,u.Optional<R>>	Collectors.minMax(Comparator<? super T> comparator, BiFunction<? super T,? super T,? extends R> finisher)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T> Collector<T,?,u.Optional<Pair<T,T>>>	Collectors.minMaxBy(Function<? super T,? extends Comparable> keyMapper)
static <T, R> Collector<T,?,u.Optional<R>>	Collectors.minMaxBy(Function<? super T,? extends Comparable> keyMapper, BiFunction<? super T,? super T,? extends R> finisher)
static <T extends Comparable<? super T>> Collector<T,?,Pair<T,T>>	Collectors.minMaxOrThrow()
static <T> Collector<T,?,Pair<T,T>>	Collectors.minMaxOrThrow(Comparator<? super T> comparator)
static <T extends Comparable<? super T>> Collector<T,?,T>	Collectors.minOrGet(Supplier<? extends T> other)
static <T> Collector<T,?,T>	Collectors.minOrGet(Comparator<? super T> comparator, Supplier<? extends T> other)
static <T extends Comparable<? super T>> Collector<T,?,T>	Collectors.minOrThrow()
static <T> Collector<T,?,T>	Collectors.minOrThrow(Comparator<? super T> comparator)
static <T> Collector<T,?,T>	Collectors.minOrThrow(Comparator<? super T> comparator, Supplier<? extends RuntimeException> exceptionSupplier)
static <T, A, R> Collector<T,A,R>	Collector.of(Supplier<A> supplier, BiConsumer<A,T> accumulator, BinaryOperator<A> combiner, Function<A,R> finisher, Collector.Characteristics... characteristics)
static <T, R> Collector<T,R,R>	Collector.of(Supplier<R> supplier, BiConsumer<R,T> accumulator, BinaryOperator<R> combiner, Collector.Characteristics... characteristics)
static <T, A, R> Collector<T,A,R>	Collector.of(Collector<T,A,R> collector)	Deprecated. replaced by from(java.util.stream.Collector)
static <T> Collector<T,?,u.Optional<T>>	Collectors.onlyOne()	DuplicatedResultException is threw if there are more than one values are collected.
static <T> Collector<T,?,u.Optional<T>>	Collectors.onlyOne(Predicate<? super T> predicate)	DuplicatedResultException is threw if there are more than one values are collected.
static <T> Collector<T,?,Map<Boolean,List<T>>>	Collectors.partitioningBy(Predicate<? super T> predicate)
static <T, D, A> Collector<T,?,Map<Boolean,D>>	Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
static <T> Collector<T,?,u.Optional<T>>	Collectors.reducing(BinaryOperator<T> op)
static <T, U> Collector<T,?,u.Optional<U>>	Collectors.reducing(Function<? super T,? extends U> mapper, BinaryOperator<U> op)
static <T> Collector<T,?,T>	Collectors.reducing(T identity, BinaryOperator<T> op)
static <T, U> Collector<T,?,U>	Collectors.reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)
static <T> Collector<T,?,T>	Collectors.reducingOrGet(BinaryOperator<T> op, Supplier<? extends T> other)
static <T, U> Collector<T,?,U>	Collectors.reducingOrGet(Function<? super T,? extends U> mapper, BinaryOperator<U> op, Supplier<? extends U> other)
static <T> Collector<T,?,T>	Collectors.reducingOrThrow(BinaryOperator<T> op)
static <T> Collector<T,?,T>	Collectors.reducingOrThrow(BinaryOperator<T> op, Supplier<? extends RuntimeException> exceptionSupplier)
static <T, U> Collector<T,?,U>	Collectors.reducingOrThrow(Function<? super T,? extends U> mapper, BinaryOperator<U> op)
static <T, U> Collector<T,?,U>	Collectors.reducingOrThrow(Function<? super T,? extends U> mapper, BinaryOperator<U> op, Supplier<? extends RuntimeException> exceptionSupplier)
static <T> Collector<T,?,BigDecimalSummaryStatistics>	Collectors.summarizingBigDecimal(Function<? super T,BigDecimal> mapper)
static <T> Collector<T,?,BigIntegerSummaryStatistics>	Collectors.summarizingBigInteger(Function<? super T,BigInteger> mapper)
static <T> Collector<T,?,ByteSummaryStatistics>	Collectors.summarizingByte(ToByteFunction<? super T> mapper)
static <T> Collector<T,?,CharSummaryStatistics>	Collectors.summarizingChar(ToCharFunction<? super T> mapper)
static <T> Collector<T,?,DoubleSummaryStatistics>	Collectors.summarizingDouble(ToDoubleFunction<? super T> mapper)
static <T> Collector<T,?,FloatSummaryStatistics>	Collectors.summarizingFloat(ToFloatFunction<? super T> mapper)
static <T> Collector<T,?,IntSummaryStatistics>	Collectors.summarizingInt(ToIntFunction<? super T> mapper)
static <T> Collector<T,?,LongSummaryStatistics>	Collectors.summarizingLong(ToLongFunction<? super T> mapper)
static <T> Collector<T,?,ShortSummaryStatistics>	Collectors.summarizingShort(ToShortFunction<? super T> mapper)
static <T> Collector<T,?,BigDecimal>	Collectors.summingBigDecimal(Function<? super T,BigDecimal> mapper)
static <T> Collector<T,?,BigInteger>	Collectors.summingBigInteger(Function<? super T,BigInteger> mapper)
static <T> Collector<T,?,Double>	Collectors.summingDouble(ToDoubleFunction<? super T> mapper)
static <T> Collector<T,?,Long>	Collectors.summingInt(ToIntFunction<? super T> mapper)
static <T> Collector<T,?,Long>	Collectors.summingLong(ToLongFunction<? super T> mapper)
static <T> Collector<T,?,Object[]>	Collectors.toArray()
static <T, A> Collector<T,?,A[]>	Collectors.toArray(IntFunction<A[]> arraySupplier)
static <T, A> Collector<T,?,A[]>	Collectors.toArray(Supplier<A[]> arraySupplier)
static <T, K, V> Collector<T,?,BiMap<K,V>>	Collectors.toBiMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
static <T, K, V> Collector<T,?,BiMap<K,V>>	Collectors.toBiMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
static <T, K, V> Collector<T,?,BiMap<K,V>>	Collectors.toBiMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<BiMap<K,V>> mapFactory)
static <T, K, V> Collector<T,?,BiMap<K,V>>	Collectors.toBiMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Supplier<BiMap<K,V>> mapFactory)
static Collector<Boolean,?,boolean[]>	Collectors.toBooleanArray()
static Collector<Boolean,?,BooleanList>	Collectors.toBooleanList()
static Collector<Byte,?,byte[]>	Collectors.toByteArray()
static Collector<Byte,?,ByteList>	Collectors.toByteList()
static Collector<Character,?,char[]>	Collectors.toCharArray()
static Collector<Character,?,CharList>	Collectors.toCharList()
static <T, C extends Collection<T>> Collector<T,?,C>	Collectors.toCollection(Supplier<? extends C> collectionFactory)
static <T, C extends Collection<T>> Collector<T,?,C>	Collectors.toCollection(Supplier<? extends C> collectionFactory, int atMostSize)
static <T, K, V> Collector<T,?,ConcurrentMap<K,V>>	Collectors.toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
static <T, K, V> Collector<T,?,ConcurrentMap<K,V>>	Collectors.toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
static <T, K, V, M extends ConcurrentMap<K, V>> Collector<T,?,M>	Collectors.toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
static <T, K, V, M extends ConcurrentMap<K, V>> Collector<T,?,M>	Collectors.toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Supplier<? extends M> mapFactory)
static <T> Collector<T,?,DataSet>	Collectors.toDataSet()
static <T> Collector<T,?,DataSet>	Collectors.toDataSet(List<String> columnNames)
static <T> Collector<T,?,Deque<T>>	Collectors.toDeque()
static Collector<Double,?,double[]>	Collectors.toDoubleArray()
static Collector<Double,?,DoubleList>	Collectors.toDoubleList()
static Collector<Float,?,float[]>	Collectors.toFloatArray()
static Collector<Float,?,FloatList>	Collectors.toFloatList()
static <T> Collector<T,?,ImmutableList<T>>	Collectors.toImmutableList()
static <K, V> Collector<Map.Entry<K,V>,?,ImmutableMap<K,V>>	Collectors.toImmutableMap()
static <K, V> Collector<Map.Entry<K,V>,?,ImmutableMap<K,V>>	Collectors.toImmutableMap(BinaryOperator<V> mergeFunction)
static <T, K, V> Collector<T,?,ImmutableMap<K,V>>	Collectors.toImmutableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
static <T, K, V> Collector<T,?,ImmutableMap<K,V>>	Collectors.toImmutableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
static <T> Collector<T,?,ImmutableSet<T>>	Collectors.toImmutableSet()
static Collector<Integer,?,int[]>	Collectors.toIntArray()
static Collector<Integer,?,IntList>	Collectors.toIntList()
static <T, K, V> Collector<T,?,Map<K,V>>	Collectors.toLinkedHashMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
static <T, K, V> Collector<T,?,Map<K,V>>	Collectors.toLinkedHashMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
static <T> Collector<T,?,Set<T>>	Collectors.toLinkedHashSet()
static <T> Collector<T,?,LinkedList<T>>	Collectors.toLinkedList()
static <T> Collector<T,?,List<T>>	Collectors.toList()
static <T> Collector<T,?,List<T>>	Collectors.toList(int atMostSize)
static Collector<Long,?,long[]>	Collectors.toLongArray()
static Collector<Long,?,LongList>	Collectors.toLongList()
static <T> Collector<T,?,LongMultiset<T>>	Collectors.toLongMultiset()
static <T> Collector<T,?,LongMultiset<T>>	Collectors.toLongMultiset(Supplier<LongMultiset<T>> supplier)
static <K, V> Collector<Map.Entry<K,V>,?,Map<K,V>>	Collectors.toMap()
static <K, V> Collector<Map.Entry<K,V>,?,Map<K,V>>	Collectors.toMap(BinaryOperator<V> mergeFunction)
static <K, V, M extends Map<K, V>> Collector<Map.Entry<K,V>,?,M>	Collectors.toMap(BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
static <T, K, V> Collector<T,?,Map<K,V>>	Collectors.toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
static <T, K, V> Collector<T,?,Map<K,V>>	Collectors.toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
static <T, K, V, M extends Map<K, V>> Collector<T,?,M>	Collectors.toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
static <T, K, V, M extends Map<K, V>> Collector<T,?,M>	Collectors.toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Supplier<? extends M> mapFactory)
static <K, V, M extends Map<K, V>> Collector<Map.Entry<K,V>,?,M>	Collectors.toMap(Supplier<? extends M> mapFactory)
static <K, V> Collector<Map.Entry<? extends K,? extends V>,?,ListMultimap<K,V>>	Collectors.toMultimap()
static <T, K> Collector<T,?,ListMultimap<K,T>>	Collectors.toMultimap(Function<? super T,? extends K> keyMapper)
static <T, K, V> Collector<T,?,ListMultimap<K,V>>	Collectors.toMultimap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
static <T, K, V, C extends Collection<V>, M extends Multimap<K, V, C>> Collector<T,?,M>	Collectors.toMultimap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Supplier<? extends M> mapFactory)
static <T, K, C extends Collection<T>, M extends Multimap<K, T, C>> Collector<T,?,M>	Collectors.toMultimap(Function<? super T,? extends K> keyMapper, Supplier<? extends M> mapFactory)
static <K, V, C extends Collection<V>, M extends Multimap<K, V, C>> Collector<Map.Entry<? extends K,? extends V>,?,M>	Collectors.toMultimap(Supplier<? extends M> mapFactory)
static <T> Collector<T,?,Multiset<T>>	Collectors.toMultiset()
static <T> Collector<T,?,Multiset<T>>	Collectors.toMultiset(Supplier<Multiset<T>> supplier)
static <T> Collector<T,?,Queue<T>>	Collectors.toQueue()
static <T> Collector<T,?,Set<T>>	Collectors.toSet()
static <T> Collector<T,?,Set<T>>	Collectors.toSet(int atMostSize)
static Collector<Short,?,short[]>	Collectors.toShortArray()
static Collector<Short,?,ShortList>	Collectors.toShortList()

Methods in com.landawn.abacus.util.stream with parameters of type Collector

Modifier and Type	Method	Description
abstract <R, A> Stream<R>	Stream.collapse(BiPredicate<? super T,? super T> collapsible, Collector<? super T,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract <R, A> Stream<R>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible, Collector<? super T,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
<R, A> Stream<R>	EntryStream.collapseByKey(BiPredicate<? super K,? super K> collapsible, Collector<? super V,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
<R, A> R	EntryStream.collect(Collector<? super Map.Entry<K,V>,A,R> collector)
abstract <R, A> R	Stream.collect(Collector<? super T,A,R> collector)
<R, A, RR, E extends Exception> RR	EntryStream.collectAndThen(Collector<? super Map.Entry<K,V>,A,R> downstream, Throwables.Function<? super R,RR,E> finisher)
abstract <R, A, RR, E extends Exception> RR	Stream.collectAndThen(Collector<? super T,A,R> downstream, Throwables.Function<? super R,RR,E> func)
static <T, A, R, RR> Collector<T,A,RR>	Collectors.collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
static <T, A1, A2, R1, R2> Collector<T,Tuple.Tuple2<A1,A2>,Tuple.Tuple2<R1,R2>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2)
static <T, A1, A2, R1, R2, R> Collector<T,Tuple.Tuple2<A1,A2>,R>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, BiFunction<? super R1,? super R2,R> finisher)
static <T, A1, A2, A3, R1, R2, R3> Collector<T,Tuple.Tuple3<A1,A2,A3>,Tuple.Tuple3<R1,R2,R3>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3)
static <T, A1, A2, A3, R1, R2, R3, R> Collector<T,Tuple.Tuple3<A1,A2,A3>,R>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, TriFunction<? super R1,? super R2,? super R3,R> finisher)
static <T, A1, A2, A3, A4, R1, R2, R3, R4> Collector<T,Tuple.Tuple4<A1,A2,A3,A4>,Tuple.Tuple4<R1,R2,R3,R4>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, Collector<? super T,A4,R4> collector4)
static <T, A1, A2, A3, A4, A5, R1, R2, R3, R4, R5> Collector<T,Tuple.Tuple5<A1,A2,A3,A4,A5>,Tuple.Tuple5<R1,R2,R3,R4,R5>>	Collectors.combine(Collector<? super T,A1,R1> collector1, Collector<? super T,A2,R2> collector2, Collector<? super T,A3,R3> collector3, Collector<? super T,A4,R4> collector4, Collector<? super T,A5,R5> collector5)
static <T, A, R> Collector<T,?,R>	Collectors.filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
abstract <K, A, D, E extends Exception> Map<K,D>	Stream.flatGroupTo(Throwables.Function<? super T,? extends Collection<? extends K>,E> flatKeyMapper, Collector<? super T,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	Stream.flatGroupTo(Throwables.Function<? super T,? extends Collection<? extends K>,E> flatKeyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, V, A, D, E extends Exception, E2 extends Exception> Map<K,D>	Stream.flatGroupTo(Throwables.Function<? super T,? extends Collection<? extends K>,E> flatKeyMapper, Throwables.BiFunction<? super K,? super T,? extends V,E2> valueMapper, Collector<? super V,A,D> downstream)
abstract <K, V, A, D, M extends Map<K, D>, E extends Exception, E2 extends Exception> M	Stream.flatGroupTo(Throwables.Function<? super T,? extends Collection<? extends K>,E> flatKeyMapper, Throwables.BiFunction<? super K,? super T,? extends V,E2> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends M> mapFactory)
static <T, T2, U, A, R> Collector<T,?,R>	Collectors.flatMapping(Function<? super T,? extends Stream<? extends T2>> flatMapper, BiFunction<? super T,? super T2,? extends U> mapper, Collector<? super U,A,R> downstream)
static <T, U, A, R> Collector<T,?,R>	Collectors.flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)
static <T, T2, U, A, R> Collector<T,?,R>	Collectors.flattMapping(Function<? super T,? extends Collection<? extends T2>> flatMapper, BiFunction<? super T,? super T2,? extends U> mapper, Collector<? super U,A,R> downstream)
static <T, U, A, R> Collector<T,?,R>	Collectors.flattMapping(Function<? super T,? extends Collection<? extends U>> mapper, Collector<? super U,A,R> downstream)
<KK, A, D> EntryStream<KK,D>	EntryStream.groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super Map.Entry<K,V>,A,D> downstream)
<KK, A, D> EntryStream<KK,D>	EntryStream.groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super Map.Entry<K,V>,A,D> downstream, Supplier<? extends Map<KK,D>> mapFactory)
<A, D> EntryStream<K,D>	EntryStream.groupBy(Collector<? super Map.Entry<K,V>,A,D> downstream)
<A, D> EntryStream<K,D>	EntryStream.groupBy(Collector<? super Map.Entry<K,V>,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
abstract <K, V, A, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,A,D> downstream)
abstract <K, V, A, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
abstract <K, A, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream)
abstract <K, A, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
abstract <K, V, A, D> EntryStream<K,D>	Stream.groupByToEntry(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,A,D> downstream)
abstract <K, V, A, D> EntryStream<K,D>	Stream.groupByToEntry(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
abstract <K, A, D> EntryStream<K,D>	Stream.groupByToEntry(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream)
abstract <K, A, D> EntryStream<K,D>	Stream.groupByToEntry(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
static <T, K, A, D> Collector<T,?,Map<K,D>>	Collectors.groupingBy(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream)
static <T, K, A, D, M extends Map<K, D>> Collector<T,?,M>	Collectors.groupingBy(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
static <T, K, A, D> Collector<T,?,ConcurrentMap<K,D>>	Collectors.groupingByConcurrent(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream)
static <T, K, A, D, M extends ConcurrentMap<K, D>> Collector<T,?,M>	Collectors.groupingByConcurrent(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <U, K, A, D, R> Stream<R>	Stream.groupJoin(Stream<? extends U> b, Function<? super T,? extends K> leftKeyMapper, Function<? super U,? extends K> rightKeyMapper, Collector<? super U,A,D> downstream, BiFunction<? super T,? super D,R> func)	The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
abstract <U, K, A, D> Stream<Pair<T,D>>	Stream.groupJoin(Collection<? extends U> b, Function<? super T,? extends K> leftKeyMapper, Function<? super U,? extends K> rightKeyMapper, Collector<? super U,A,D> downstream)	The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
abstract <U, K, A, D, R> Stream<R>	Stream.groupJoin(Collection<? extends U> b, Function<? super T,? extends K> leftKeyMapper, Function<? super U,? extends K> rightKeyMapper, Collector<? super U,A,D> downstream, BiFunction<? super T,? super D,R> func)	The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
abstract <K, A, D, E extends Exception> Map<K,D>	ByteStream.groupTo(Throwables.ByteFunction<? extends K,E> keyMapper, Collector<Byte,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	ByteStream.groupTo(Throwables.ByteFunction<? extends K,E> keyMapper, Collector<Byte,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, A, D, E extends Exception> Map<K,D>	CharStream.groupTo(Throwables.CharFunction<? extends K,E> keyMapper, Collector<Character,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	CharStream.groupTo(Throwables.CharFunction<? extends K,E> keyMapper, Collector<Character,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, A, D, E extends Exception> Map<K,D>	DoubleStream.groupTo(Throwables.DoubleFunction<? extends K,E> keyMapper, Collector<Double,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	DoubleStream.groupTo(Throwables.DoubleFunction<? extends K,E> keyMapper, Collector<Double,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, A, D, E extends Exception> Map<K,D>	FloatStream.groupTo(Throwables.FloatFunction<? extends K,E> keyMapper, Collector<Float,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	FloatStream.groupTo(Throwables.FloatFunction<? extends K,E> keyMapper, Collector<Float,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, A, D, E extends Exception> Map<K,D>	IntStream.groupTo(Throwables.IntFunction<? extends K,E> keyMapper, Collector<Integer,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	IntStream.groupTo(Throwables.IntFunction<? extends K,E> keyMapper, Collector<Integer,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, A, D, E extends Exception> Map<K,D>	LongStream.groupTo(Throwables.LongFunction<? extends K,E> keyMapper, Collector<Long,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	LongStream.groupTo(Throwables.LongFunction<? extends K,E> keyMapper, Collector<Long,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, A, D, E extends Exception> Map<K,D>	ShortStream.groupTo(Throwables.ShortFunction<? extends K,E> keyMapper, Collector<Short,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	ShortStream.groupTo(Throwables.ShortFunction<? extends K,E> keyMapper, Collector<Short,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, A, D, E extends Exception> Map<K,D>	Stream.groupTo(Throwables.Function<? super T,? extends K,E> keyMapper, Collector<? super T,A,D> downstream)
abstract <K, A, D, M extends Map<K, D>, E extends Exception> M	Stream.groupTo(Throwables.Function<? super T,? extends K,E> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K, V, A, D, E extends Exception, E2 extends Exception> Map<K,D>	Stream.groupTo(Throwables.Function<? super T,? extends K,E> keyMapper, Throwables.Function<? super T,? extends V,E2> valueMapper, Collector<? super V,A,D> downstream)
abstract <K, V, A, D, M extends Map<K, D>, E extends Exception, E2 extends Exception> M	Stream.groupTo(Throwables.Function<? super T,? extends K,E> keyMapper, Throwables.Function<? super T,? extends V,E2> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <U, A, D, R> Stream<R>	Stream.joinByRange(Stream<U> b, BiPredicate<? super T,? super U> predicate, Collector<? super U,A,D> collector, BiFunction<? super T,? super D,R> func)
abstract <U, A, D, R> Stream<R>	Stream.joinByRange(Stream<U> b, BiPredicate<? super T,? super U> predicate, Collector<? super U,A,D> collector, BiFunction<? super T,? super D,R> func, Function<Iterator<U>,Stream<R>> mapperForUnJoinedEelements)
abstract <U, A, R> Stream<Pair<T,R>>	Stream.joinByRange(Stream<U> b, BiPredicate<? super T,? super U> predicate, Collector<? super U,A,R> collector)
abstract <U, A, D, R> Stream<R>	Stream.joinByRange(Iterator<U> b, BiPredicate<? super T,? super U> predicate, Collector<? super U,A,D> collector, BiFunction<? super T,? super D,R> func)
abstract <U, A, D, R> Stream<R>	Stream.joinByRange(Iterator<U> b, BiPredicate<? super T,? super U> predicate, Collector<? super U,A,D> collector, BiFunction<? super T,? super D,R> func, Function<Iterator<U>,Stream<R>> mapperForUnJoinedEelements)
abstract <U, A, R> Stream<Pair<T,R>>	Stream.joinByRange(Iterator<U> b, BiPredicate<? super T,? super U> predicate, Collector<? super U,A,R> collector)
static <T, U, A, R> Collector<T,?,R>	Collectors.mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)
static <T extends Comparable, A, D> Collector<T,?,D>	Collectors.maxAll(Collector<T,A,D> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T, A, D> Collector<T,?,D>	Collectors.maxAll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T extends Comparable, A, D> Collector<T,?,u.Optional<Pair<T,D>>>	Collectors.maxAlll(Collector<T,A,D> downstream)
static <T, A, D> Collector<T,?,u.Optional<Pair<T,D>>>	Collectors.maxAlll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream)
static <T, A, D, R> Collector<T,?,R>	Collectors.maxAlll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream, Function<u.Optional<Pair<T,D>>,R> finisher)
static <T extends Comparable, A, D> Collector<T,?,D>	Collectors.minAll(Collector<T,A,D> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T, A, D> Collector<T,?,D>	Collectors.minAll(Comparator<? super T> comparator, Collector<T,A,D> downstream)	It's copied from StreamEx: https://github.com/amaembo/streamex under Apache License v2 and may be modified.
static <T extends Comparable, A, D> Collector<T,?,u.Optional<Pair<T,D>>>	Collectors.minAlll(Collector<T,A,D> downstream)
static <T, A, D> Collector<T,?,u.Optional<Pair<T,D>>>	Collectors.minAlll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream)
static <T, A, D, R> Collector<T,?,R>	Collectors.minAlll(Comparator<? super T> comparator, Collector<? super T,A,D> downstream, Function<u.Optional<Pair<T,D>>,R> finisher)
abstract <A, D> Stream<Map.Entry<Boolean,D>>	Stream.partitionBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
abstract <A, D> EntryStream<Boolean,D>	Stream.partitionByToEntry(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
static <T, D, A> Collector<T,?,Map<Boolean,D>>	Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
abstract <A, D, E extends Exception> Map<Boolean,D>	Stream.partitionTo(Throwables.Predicate<? super T,E> predicate, Collector<? super T,A,D> downstream)
abstract <A, R> Stream<R>	Stream.sliding(int windowSize, int increment, Collector<? super T,A,R> collector)
abstract <A, R> Stream<R>	Stream.sliding(int windowSize, Collector<? super T,A,R> collector)
abstract <A, R> Stream<R>	Stream.split(int chunkSize, Collector<? super T,A,R> collector)
abstract <A, R> Stream<R>	Stream.split(Predicate<? super T> predicate, Collector<? super T,A,R> collector)
abstract <A, R> Stream<R>	Stream.splitAt(int where, Collector<? super T,A,R> collector)	Split the stream into two pieces at where turns to false.
abstract <A, R> Stream<R>	Stream.splitAt(Predicate<? super T> where, Collector<? super T,A,R> collector)	Split the stream into two pieces at where turns to false.
final <K, A, D, E extends Exception> Map<K,D>	Stream.toMap(Throwables.Function<? super T,? extends K,E> keyMapper, Collector<? super T,A,D> downstream)	Deprecated. replaced by groupTo
final <K, A, D, M extends Map<K, D>, E extends Exception> M	Stream.toMap(Throwables.Function<? super T,? extends K,E> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)	Deprecated. replaced by groupTo
final <K, V, A, D, E extends Exception, E2 extends Exception> Map<K,D>	Stream.toMap(Throwables.Function<? super T,? extends K,E> keyMapper, Throwables.Function<? super T,? extends V,E2> valueMapper, Collector<? super V,A,D> downstream)	Deprecated. replaced by groupTo
final <K, V, A, D, M extends Map<K, D>, E extends Exception, E2 extends Exception> M	Stream.toMap(Throwables.Function<? super T,? extends K,E> keyMapper, Throwables.Function<? super T,? extends V,E2> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends M> mapFactory)	Deprecated. replaced by groupTo
abstract <A, R> Stream<R>	Stream.window(int maxWindowSize, Duration maxDuration, LongSupplier startTime, Collector<? super T,A,R> collector)	Split this stream at where maxWindowSize or maxDuration reaches first.
abstract <A, R> Stream<R>	Stream.window(int maxWindowSize, Duration maxDuration, Collector<? super T,A,R> collector)
abstract <A, R> Stream<R>	Stream.window(Duration duration, long incrementInMillis, LongSupplier startTime, Collector<? super T,A,R> collector)
abstract <A, R> Stream<R>	Stream.window(Duration duration, long incrementInMillis, Collector<? super T,A,R> collector)
abstract <A, R> Stream<R>	Stream.window(Duration duration, LongSupplier startTime, Collector<? super T,A,R> collector)
abstract <A, R> Stream<R>	Stream.window(Duration duration, Collector<? super T,A,R> collector)

Method parameters in com.landawn.abacus.util.stream with type arguments of type Collector

Modifier and Type	Method	Description
static <T> Collector<T,?,List<?>>	Collectors.combine(List<? extends Collector<? super T,?,?>> collectors)