## Class ConstraintCollectors

• ### Method Summary

All Methods
Modifier and Type Method Description
`static <A,​B>BiConstraintCollector<A,​B,​?,​Double>` `average​(ToIntBiFunction<A,​B> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Double>` `average​(ToIntFunction<A> groupValueMapping)`
Returns a collector that calculates an average of an `int` property of the elements that are being grouped.
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Double>` `average​(ToIntQuadFunction<A,​B,​C,​D> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Double>` `average​(ToIntTriFunction<A,​B,​C> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​BigDecimal>` `averageBigDecimal​(BiFunction<A,​B,​BigDecimal> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​BigDecimal>` `averageBigDecimal​(Function<A,​BigDecimal> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​BigDecimal>` `averageBigDecimal​(QuadFunction<A,​B,​C,​D,​BigDecimal> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​BigDecimal>` `averageBigDecimal​(TriFunction<A,​B,​C,​BigDecimal> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​BigDecimal>` `averageBigInteger​(BiFunction<A,​B,​BigInteger> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​BigDecimal>` `averageBigInteger​(Function<A,​BigInteger> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​BigDecimal>` `averageBigInteger​(QuadFunction<A,​B,​C,​D,​BigInteger> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​BigDecimal>` `averageBigInteger​(TriFunction<A,​B,​C,​BigInteger> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​Duration>` `averageDuration​(BiFunction<A,​B,​Duration> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Duration>` `averageDuration​(Function<A,​Duration> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Duration>` `averageDuration​(QuadFunction<A,​B,​C,​D,​Duration> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Duration>` `averageDuration​(TriFunction<A,​B,​C,​Duration> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​Double>` `averageLong​(ToLongBiFunction<A,​B> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Double>` `averageLong​(ToLongFunction<A> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Double>` `averageLong​(ToLongQuadFunction<A,​B,​C,​D> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Double>` `averageLong​(ToLongTriFunction<A,​B,​C> groupValueMapping)`
`static <A,​B,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResult1_,​SubResult2_>BiConstraintCollector<A,​B,​?,​Result_>` ```compose​(BiConstraintCollector<A,​B,​SubResultContainer1_,​SubResult1_> subCollector1, BiConstraintCollector<A,​B,​SubResultContainer2_,​SubResult2_> subCollector2, BiFunction<SubResult1_,​SubResult2_,​Result_> composeFunction)```
`static <A,​B,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResult1_,​SubResult2_,​SubResult3_>BiConstraintCollector<A,​B,​?,​Result_>` ```compose​(BiConstraintCollector<A,​B,​SubResultContainer1_,​SubResult1_> subCollector1, BiConstraintCollector<A,​B,​SubResultContainer2_,​SubResult2_> subCollector2, BiConstraintCollector<A,​B,​SubResultContainer3_,​SubResult3_> subCollector3, TriFunction<SubResult1_,​SubResult2_,​SubResult3_,​Result_> composeFunction)```
`static <A,​B,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResultContainer4_,​SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_>BiConstraintCollector<A,​B,​?,​Result_>` ```compose​(BiConstraintCollector<A,​B,​SubResultContainer1_,​SubResult1_> subCollector1, BiConstraintCollector<A,​B,​SubResultContainer2_,​SubResult2_> subCollector2, BiConstraintCollector<A,​B,​SubResultContainer3_,​SubResult3_> subCollector3, BiConstraintCollector<A,​B,​SubResultContainer4_,​SubResult4_> subCollector4, QuadFunction<SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_,​Result_> composeFunction)```
`static <A,​B,​C,​D,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResult1_,​SubResult2_>QuadConstraintCollector<A,​B,​C,​D,​?,​Result_>` ```compose​(QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer1_,​SubResult1_> subCollector1, QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer2_,​SubResult2_> subCollector2, BiFunction<SubResult1_,​SubResult2_,​Result_> composeFunction)```
`static <A,​B,​C,​D,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResult1_,​SubResult2_,​SubResult3_>QuadConstraintCollector<A,​B,​C,​D,​?,​Result_>` ```compose​(QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer1_,​SubResult1_> subCollector1, QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer2_,​SubResult2_> subCollector2, QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer3_,​SubResult3_> subCollector3, TriFunction<SubResult1_,​SubResult2_,​SubResult3_,​Result_> composeFunction)```
`static <A,​B,​C,​D,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResultContainer4_,​SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_>QuadConstraintCollector<A,​B,​C,​D,​?,​Result_>` ```compose​(QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer1_,​SubResult1_> subCollector1, QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer2_,​SubResult2_> subCollector2, QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer3_,​SubResult3_> subCollector3, QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer4_,​SubResult4_> subCollector4, QuadFunction<SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_,​Result_> composeFunction)```
`static <A,​B,​C,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResult1_,​SubResult2_>TriConstraintCollector<A,​B,​C,​?,​Result_>` ```compose​(TriConstraintCollector<A,​B,​C,​SubResultContainer1_,​SubResult1_> subCollector1, TriConstraintCollector<A,​B,​C,​SubResultContainer2_,​SubResult2_> subCollector2, BiFunction<SubResult1_,​SubResult2_,​Result_> composeFunction)```
`static <A,​B,​C,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResult1_,​SubResult2_,​SubResult3_>TriConstraintCollector<A,​B,​C,​?,​Result_>` ```compose​(TriConstraintCollector<A,​B,​C,​SubResultContainer1_,​SubResult1_> subCollector1, TriConstraintCollector<A,​B,​C,​SubResultContainer2_,​SubResult2_> subCollector2, TriConstraintCollector<A,​B,​C,​SubResultContainer3_,​SubResult3_> subCollector3, TriFunction<SubResult1_,​SubResult2_,​SubResult3_,​Result_> composeFunction)```
`static <A,​B,​C,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResultContainer4_,​SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_>TriConstraintCollector<A,​B,​C,​?,​Result_>` ```compose​(TriConstraintCollector<A,​B,​C,​SubResultContainer1_,​SubResult1_> subCollector1, TriConstraintCollector<A,​B,​C,​SubResultContainer2_,​SubResult2_> subCollector2, TriConstraintCollector<A,​B,​C,​SubResultContainer3_,​SubResult3_> subCollector3, TriConstraintCollector<A,​B,​C,​SubResultContainer4_,​SubResult4_> subCollector4, QuadFunction<SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_,​Result_> composeFunction)```
`static <A,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResult1_,​SubResult2_>UniConstraintCollector<A,​?,​Result_>` ```compose​(UniConstraintCollector<A,​SubResultContainer1_,​SubResult1_> subCollector1, UniConstraintCollector<A,​SubResultContainer2_,​SubResult2_> subCollector2, BiFunction<SubResult1_,​SubResult2_,​Result_> composeFunction)```
Returns a constraint collector the result of which is a composition of other constraint collectors.
`static <A,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResult1_,​SubResult2_,​SubResult3_>UniConstraintCollector<A,​?,​Result_>` ```compose​(UniConstraintCollector<A,​SubResultContainer1_,​SubResult1_> subCollector1, UniConstraintCollector<A,​SubResultContainer2_,​SubResult2_> subCollector2, UniConstraintCollector<A,​SubResultContainer3_,​SubResult3_> subCollector3, TriFunction<SubResult1_,​SubResult2_,​SubResult3_,​Result_> composeFunction)```
Returns a constraint collector the result of which is a composition of other constraint collectors.
`static <A,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResultContainer4_,​SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_>UniConstraintCollector<A,​?,​Result_>` ```compose​(UniConstraintCollector<A,​SubResultContainer1_,​SubResult1_> subCollector1, UniConstraintCollector<A,​SubResultContainer2_,​SubResult2_> subCollector2, UniConstraintCollector<A,​SubResultContainer3_,​SubResult3_> subCollector3, UniConstraintCollector<A,​SubResultContainer4_,​SubResult4_> subCollector4, QuadFunction<SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_,​Result_> composeFunction)```
Returns a constraint collector the result of which is a composition of other constraint collectors.
`static <A,​B,​ResultContainer_,​Result_>BiConstraintCollector<A,​B,​ResultContainer_,​Result_>` ```conditionally​(BiPredicate<A,​B> condition, BiConstraintCollector<A,​B,​ResultContainer_,​Result_> delegate)```
`static <A,​ResultContainer_,​Result_>UniConstraintCollector<A,​ResultContainer_,​Result_>` ```conditionally​(Predicate<A> condition, UniConstraintCollector<A,​ResultContainer_,​Result_> delegate)```
Returns a collector that delegates to the underlying collector if and only if the input tuple meets the given condition.
`static <A,​B,​C,​D,​ResultContainer_,​Result_>QuadConstraintCollector<A,​B,​C,​D,​ResultContainer_,​Result_>` ```conditionally​(QuadPredicate<A,​B,​C,​D> condition, QuadConstraintCollector<A,​B,​C,​D,​ResultContainer_,​Result_> delegate)```
`static <A,​B,​C,​ResultContainer_,​Result_>TriConstraintCollector<A,​B,​C,​ResultContainer_,​Result_>` ```conditionally​(TriPredicate<A,​B,​C> condition, TriConstraintCollector<A,​B,​C,​ResultContainer_,​Result_> delegate)```
`static <A> UniConstraintCollector<A,​?,​Integer>` `count()`
Returns a collector that counts the number of elements that are being grouped.
`static <A,​B>BiConstraintCollector<A,​B,​?,​Integer>` `countBi()`
As defined by `count()`.
`static <A> UniConstraintCollector<A,​?,​Integer>` `countDistinct()`
`static <A,​B>BiConstraintCollector<A,​B,​?,​Integer>` `countDistinct​(BiFunction<A,​B,​?> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Integer>` `countDistinct​(Function<A,​?> groupValueMapping)`
Returns a collector that counts the number of unique elements that are being grouped.
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Integer>` `countDistinct​(QuadFunction<A,​B,​C,​D,​?> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Integer>` `countDistinct​(TriFunction<A,​B,​C,​?> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​Long>` `countDistinctLong​(BiFunction<A,​B,​?> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Long>` `countDistinctLong​(Function<A,​?> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Long>` `countDistinctLong​(QuadFunction<A,​B,​C,​D,​?> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Long>` `countDistinctLong​(TriFunction<A,​B,​C,​?> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Long>` `countLong()`
As defined by `count()`.
`static <A,​B>BiConstraintCollector<A,​B,​?,​Long>` `countLongBi()`
As defined by `count()`.
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Long>` `countLongQuad()`
As defined by `count()`.
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Long>` `countLongTri()`
As defined by `count()`.
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Integer>` `countQuad()`
As defined by `count()`.
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Integer>` `countTri()`
As defined by `count()`.
`static <A extends Comparable<A>>UniConstraintCollector<A,​?,​A>` `max()`
Returns a collector that finds a maximum value in a group of `Comparable` elements.
`static <A> UniConstraintCollector<A,​?,​A>` `max​(Comparator<A> comparator)`
As defined by `max()`, only with a custom `Comparator`.
`static <A,​B,​Mapped extends Comparable<Mapped>>BiConstraintCollector<A,​B,​?,​Mapped>` `max​(BiFunction<A,​B,​Mapped> groupValueMapping)`
`static <A,​B,​Mapped>BiConstraintCollector<A,​B,​?,​Mapped>` ```max​(BiFunction<A,​B,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
As defined by `max(Function)`, only with a custom `Comparator`.
`static <A,​Mapped extends Comparable<Mapped>>UniConstraintCollector<A,​?,​Mapped>` `max​(Function<A,​Mapped> groupValueMapping)`
Returns a collector that finds a maximum value in a group of `Comparable` elements.
`static <A,​Mapped>UniConstraintCollector<A,​?,​Mapped>` ```max​(Function<A,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
As defined by `max(Function)`, only with a custom `Comparator`.
`static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>>QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped>` `max​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
`static <A,​B,​C,​D,​Mapped>QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped>` ```max​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
As defined by `max(Function)`, only with a custom `Comparator`.
`static <A,​B,​C,​Mapped extends Comparable<Mapped>>TriConstraintCollector<A,​B,​C,​?,​Mapped>` `max​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
`static <A,​B,​C,​Mapped>TriConstraintCollector<A,​B,​C,​?,​Mapped>` ```max​(TriFunction<A,​B,​C,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
As defined by `max(Function)`, only with a custom `Comparator`.
`static <A extends Comparable<A>>UniConstraintCollector<A,​?,​A>` `min()`
Returns a collector that finds a minimum value in a group of `Comparable` elements.
`static <A> UniConstraintCollector<A,​?,​A>` `min​(Comparator<A> comparator)`
As defined by `min()`, only with a custom `Comparator`.
`static <A,​B,​Mapped extends Comparable<Mapped>>BiConstraintCollector<A,​B,​?,​Mapped>` `min​(BiFunction<A,​B,​Mapped> groupValueMapping)`
`static <A,​B,​Mapped>BiConstraintCollector<A,​B,​?,​Mapped>` ```min​(BiFunction<A,​B,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
As defined by `min(Function)`, only with a custom `Comparator`.
`static <A,​Mapped extends Comparable<Mapped>>UniConstraintCollector<A,​?,​Mapped>` `min​(Function<A,​Mapped> groupValueMapping)`
Returns a collector that finds a minimum value in a group of `Comparable` elements.
`static <A,​Mapped>UniConstraintCollector<A,​?,​Mapped>` ```min​(Function<A,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
As defined by `min(Function)`, only with a custom `Comparator`.
`static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>>QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped>` `min​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
`static <A,​B,​C,​D,​Mapped>QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped>` ```min​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
As defined by `min(Function)`, only with a custom `Comparator`.
`static <A,​B,​C,​Mapped extends Comparable<Mapped>>TriConstraintCollector<A,​B,​C,​?,​Mapped>` `min​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
`static <A,​B,​C,​Mapped>TriConstraintCollector<A,​B,​C,​?,​Mapped>` ```min​(TriFunction<A,​B,​C,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
As defined by `min(Function)`, only with a custom `Comparator`.
`static <A,​B,​Result>BiConstraintCollector<A,​B,​?,​Result>` ```sum​(BiFunction<? super A,​? super B,​Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)```
`static <A,​Result>UniConstraintCollector<A,​?,​Result>` ```sum​(Function<? super A,​Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)```
`static <A,​B>BiConstraintCollector<A,​B,​?,​Integer>` `sum​(ToIntBiFunction<? super A,​? super B> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Integer>` `sum​(ToIntFunction<? super A> groupValueMapping)`
Returns a collector that sums an `int` property of the elements that are being grouped.
`static <A,​B,​C,​D,​Result>QuadConstraintCollector<A,​B,​C,​D,​?,​Result>` ```sum​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)```
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Integer>` `sum​(ToIntQuadFunction<? super A,​? super B,​? super C,​? super D> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Integer>` `sum​(ToIntTriFunction<? super A,​? super B,​? super C> groupValueMapping)`
`static <A,​B,​C,​Result>TriConstraintCollector<A,​B,​C,​?,​Result>` ```sum​(TriFunction<? super A,​? super B,​? super C,​Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)```
`static <A,​B>BiConstraintCollector<A,​B,​?,​BigDecimal>` `sumBigDecimal​(BiFunction<? super A,​? super B,​BigDecimal> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​BigDecimal>` `sumBigDecimal​(Function<? super A,​BigDecimal> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​BigDecimal>` `sumBigDecimal​(QuadFunction<? super A,​? super B,​? super C,​? super D,​BigDecimal> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​BigDecimal>` `sumBigDecimal​(TriFunction<? super A,​? super B,​? super C,​BigDecimal> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​BigInteger>` `sumBigInteger​(BiFunction<? super A,​? super B,​BigInteger> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​BigInteger>` `sumBigInteger​(Function<? super A,​BigInteger> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​BigInteger>` `sumBigInteger​(QuadFunction<? super A,​? super B,​? super C,​? super D,​BigInteger> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​BigInteger>` `sumBigInteger​(TriFunction<? super A,​? super B,​? super C,​BigInteger> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​Duration>` `sumDuration​(BiFunction<? super A,​? super B,​Duration> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Duration>` `sumDuration​(Function<? super A,​Duration> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Duration>` `sumDuration​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Duration> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Duration>` `sumDuration​(TriFunction<? super A,​? super B,​? super C,​Duration> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​Long>` `sumLong​(ToLongBiFunction<? super A,​? super B> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Long>` `sumLong​(ToLongFunction<? super A> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Long>` `sumLong​(ToLongQuadFunction<? super A,​? super B,​? super C,​? super D> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Long>` `sumLong​(ToLongTriFunction<? super A,​? super B,​? super C> groupValueMapping)`
`static <A,​B>BiConstraintCollector<A,​B,​?,​Period>` `sumPeriod​(BiFunction<? super A,​? super B,​Period> groupValueMapping)`
`static <A> UniConstraintCollector<A,​?,​Period>` `sumPeriod​(Function<? super A,​Period> groupValueMapping)`
`static <A,​B,​C,​D>QuadConstraintCollector<A,​B,​C,​D,​?,​Period>` `sumPeriod​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Period> groupValueMapping)`
`static <A,​B,​C>TriConstraintCollector<A,​B,​C,​?,​Period>` `sumPeriod​(TriFunction<? super A,​? super B,​? super C,​Period> groupValueMapping)`
`static <A,​B,​Mapped,​Result extends Collection<Mapped>>BiConstraintCollector<A,​B,​?,​Result>` ```toCollection​(BiFunction<A,​B,​Mapped> groupValueMapping, IntFunction<Result> collectionFunction)```
Deprecated.
`static <A,​Mapped,​Result extends Collection<Mapped>>UniConstraintCollector<A,​?,​Result>` ```toCollection​(Function<A,​Mapped> groupValueMapping, IntFunction<Result> collectionFunction)```
Deprecated.
`static <A,​Result extends Collection<A>>UniConstraintCollector<A,​?,​Result>` `toCollection​(IntFunction<Result> collectionFunction)`
Deprecated.
`static <A,​B,​C,​D,​Mapped,​Result extends Collection<Mapped>>QuadConstraintCollector<A,​B,​C,​D,​?,​Result>` ```toCollection​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping, IntFunction<Result> collectionFunction)```
Deprecated.
`static <A,​B,​C,​Mapped,​Result extends Collection<Mapped>>TriConstraintCollector<A,​B,​C,​?,​Result>` ```toCollection​(TriFunction<A,​B,​C,​Mapped> groupValueMapping, IntFunction<Result> collectionFunction)```
Deprecated.
`static <A> UniConstraintCollector<A,​?,​List<A>>` `toList()`
Creates constraint collector that returns `List` of the same element type as the `ConstraintStream`.
`static <A,​B,​Mapped>BiConstraintCollector<A,​B,​?,​List<Mapped>>` `toList​(BiFunction<A,​B,​Mapped> groupValueMapping)`
`static <A,​Mapped>UniConstraintCollector<A,​?,​List<Mapped>>` `toList​(Function<A,​Mapped> groupValueMapping)`
Creates constraint collector that returns `List` of the given element type.
`static <A,​B,​C,​D,​Mapped>QuadConstraintCollector<A,​B,​C,​D,​?,​List<Mapped>>` `toList​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
`static <A,​B,​C,​Mapped>TriConstraintCollector<A,​B,​C,​?,​List<Mapped>>` `toList​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
`static <A,​B,​Key,​Value>BiConstraintCollector<A,​B,​?,​Map<Key,​Set<Value>>>` ```toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper)```
`static <A,​B,​Key,​Value>BiConstraintCollector<A,​B,​?,​Map<Key,​Value>>` ```toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)```
`static <A,​B,​Key,​Value,​ValueSet extends Set<Value>>BiConstraintCollector<A,​B,​?,​Map<Key,​ValueSet>>` ```toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)```
`static <A,​Key,​Value>UniConstraintCollector<A,​?,​Map<Key,​Set<Value>>>` ```toMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper)```
Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.
`static <A,​Key,​Value>UniConstraintCollector<A,​?,​Map<Key,​Value>>` ```toMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)```
Creates a constraint collector that returns a `Map`.
`static <A,​Key,​Value,​ValueSet extends Set<Value>>UniConstraintCollector<A,​?,​Map<Key,​ValueSet>>` ```toMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)```
Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.
`static <A,​B,​C,​D,​Key,​Value>QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​Set<Value>>>` ```toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper)```
`static <A,​B,​C,​D,​Key,​Value>QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​Value>>` ```toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)```
`static <A,​B,​C,​D,​Key,​Value,​ValueSet extends Set<Value>>QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​ValueSet>>` ```toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)```
`static <A,​B,​C,​Key,​Value>TriConstraintCollector<A,​B,​C,​?,​Map<Key,​Set<Value>>>` ```toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper)```
`static <A,​B,​C,​Key,​Value>TriConstraintCollector<A,​B,​C,​?,​Map<Key,​Value>>` ```toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)```
`static <A,​B,​C,​Key,​Value,​ValueSet extends Set<Value>>TriConstraintCollector<A,​B,​C,​?,​Map<Key,​ValueSet>>` ```toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)```
`static <A> UniConstraintCollector<A,​?,​Set<A>>` `toSet()`
Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`.
`static <A,​B,​Mapped>BiConstraintCollector<A,​B,​?,​Set<Mapped>>` `toSet​(BiFunction<A,​B,​Mapped> groupValueMapping)`
`static <A,​Mapped>UniConstraintCollector<A,​?,​Set<Mapped>>` `toSet​(Function<A,​Mapped> groupValueMapping)`
Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`.
`static <A,​B,​C,​D,​Mapped>QuadConstraintCollector<A,​B,​C,​D,​?,​Set<Mapped>>` `toSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
`static <A,​B,​C,​Mapped>TriConstraintCollector<A,​B,​C,​?,​Set<Mapped>>` `toSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
`static <A,​B,​Key extends Comparable<Key>,​Value>BiConstraintCollector<A,​B,​?,​SortedMap<Key,​Set<Value>>>` ```toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper)```
`static <A,​B,​Key extends Comparable<Key>,​Value>BiConstraintCollector<A,​B,​?,​SortedMap<Key,​Value>>` ```toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)```
`static <A,​B,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>>BiConstraintCollector<A,​B,​?,​SortedMap<Key,​ValueSet>>` ```toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)```
`static <A,​Key extends Comparable<Key>,​Value>UniConstraintCollector<A,​?,​SortedMap<Key,​Set<Value>>>` ```toSortedMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper)```
Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.
`static <A,​Key extends Comparable<Key>,​Value>UniConstraintCollector<A,​?,​SortedMap<Key,​Value>>` ```toSortedMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)```
Creates a constraint collector that returns a `SortedMap`.
`static <A,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>>UniConstraintCollector<A,​?,​SortedMap<Key,​ValueSet>>` ```toSortedMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)```
Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.
`static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value>QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​Set<Value>>>` ```toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper)```
`static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value>QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​Value>>` ```toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)```
`static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>>QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​ValueSet>>` ```toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)```
`static <A,​B,​C,​Key extends Comparable<Key>,​Value>TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​Set<Value>>>` ```toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper)```
`static <A,​B,​C,​Key extends Comparable<Key>,​Value>TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​Value>>` ```toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)```
`static <A,​B,​C,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>>TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​ValueSet>>` ```toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)```
`static <A extends Comparable<A>>UniConstraintCollector<A,​?,​SortedSet<A>>` `toSortedSet()`
Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
`static <A> UniConstraintCollector<A,​?,​SortedSet<A>>` `toSortedSet​(Comparator<A> comparator)`
As defined by `toSortedSet()`, only with a custom `Comparator`.
`static <A,​B,​Mapped extends Comparable<Mapped>>BiConstraintCollector<A,​B,​?,​SortedSet<Mapped>>` `toSortedSet​(BiFunction<A,​B,​Mapped> groupValueMapping)`
`static <A,​B,​Mapped>BiConstraintCollector<A,​B,​?,​SortedSet<Mapped>>` ```toSortedSet​(BiFunction<A,​B,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
`static <A,​Mapped extends Comparable<Mapped>>UniConstraintCollector<A,​?,​SortedSet<Mapped>>` `toSortedSet​(Function<A,​Mapped> groupValueMapping)`
Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
`static <A,​Mapped>UniConstraintCollector<A,​?,​SortedSet<Mapped>>` ```toSortedSet​(Function<A,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
`static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>>QuadConstraintCollector<A,​B,​C,​D,​?,​SortedSet<Mapped>>` `toSortedSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
`static <A,​B,​C,​D,​Mapped>QuadConstraintCollector<A,​B,​C,​D,​?,​SortedSet<Mapped>>` ```toSortedSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
`static <A,​B,​C,​Mapped extends Comparable<Mapped>>TriConstraintCollector<A,​B,​C,​?,​SortedSet<Mapped>>` `toSortedSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
`static <A,​B,​C,​Mapped>TriConstraintCollector<A,​B,​C,​?,​SortedSet<Mapped>>` ```toSortedSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping, Comparator<Mapped> comparator)```
• ### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Method Detail

• #### count

`public static <A> UniConstraintCollector<A,​?,​Integer> count()`
Returns a collector that counts the number of elements that are being grouped.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(count())` returns `5`.

The default result of the collector (e.g. when never called) is `0`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### countLong

`public static <A> UniConstraintCollector<A,​?,​Long> countLong()`
As defined by `count()`.
• #### countBi

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Integer> countBi()`
As defined by `count()`.
• #### countLongBi

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Long> countLongBi()`
As defined by `count()`.
• #### countTri

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer> countTri()`
As defined by `count()`.
• #### countLongTri

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long> countLongTri()`
As defined by `count()`.

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer> countQuad()`
As defined by `count()`.

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long> countLongQuad()`
As defined by `count()`.
• #### countDistinct

`public static <A> UniConstraintCollector<A,​?,​Integer> countDistinct​(Function<A,​?> groupValueMapping)`
Returns a collector that counts the number of unique elements that are being grouped. Uniqueness is determined by `equality`.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(countDistinct(Person::getAge))` returns `3`, one for age 20, 25 and 30 each.

The default result of the collector (e.g. when never called) is `0`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### countDistinctLong

`public static <A> UniConstraintCollector<A,​?,​Long> countDistinctLong​(Function<A,​?> groupValueMapping)`
• #### countDistinct

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Integer> countDistinct​(BiFunction<A,​B,​?> groupValueMapping)`
• #### countDistinctLong

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Long> countDistinctLong​(BiFunction<A,​B,​?> groupValueMapping)`
• #### countDistinct

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer> countDistinct​(TriFunction<A,​B,​C,​?> groupValueMapping)`
• #### countDistinctLong

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long> countDistinctLong​(TriFunction<A,​B,​C,​?> groupValueMapping)`
• #### countDistinct

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer> countDistinct​(QuadFunction<A,​B,​C,​D,​?> groupValueMapping)`
• #### countDistinctLong

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long> countDistinctLong​(QuadFunction<A,​B,​C,​D,​?> groupValueMapping)`
• #### sum

`public static <A> UniConstraintCollector<A,​?,​Integer> sum​(ToIntFunction<? super A> groupValueMapping)`
Returns a collector that sums an `int` property of the elements that are being grouped.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(sum(Person::getAge))` returns `125`.

The default result of the collector (e.g. when never called) is `0`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### sumLong

`public static <A> UniConstraintCollector<A,​?,​Long> sumLong​(ToLongFunction<? super A> groupValueMapping)`
• #### sum

```public static <A,​Result> UniConstraintCollector<A,​?,​Result> sum​(Function<? super A,​Result> groupValueMapping,
Result zero,
BinaryOperator<Result> subtractor)```
• #### sumBigDecimal

`public static <A> UniConstraintCollector<A,​?,​BigDecimal> sumBigDecimal​(Function<? super A,​BigDecimal> groupValueMapping)`
• #### sumBigInteger

`public static <A> UniConstraintCollector<A,​?,​BigInteger> sumBigInteger​(Function<? super A,​BigInteger> groupValueMapping)`
• #### sumDuration

`public static <A> UniConstraintCollector<A,​?,​Duration> sumDuration​(Function<? super A,​Duration> groupValueMapping)`
• #### sumPeriod

`public static <A> UniConstraintCollector<A,​?,​Period> sumPeriod​(Function<? super A,​Period> groupValueMapping)`
• #### sum

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Integer> sum​(ToIntBiFunction<? super A,​? super B> groupValueMapping)`
• #### sumLong

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Long> sumLong​(ToLongBiFunction<? super A,​? super B> groupValueMapping)`
• #### sum

```public static <A,​B,​Result> BiConstraintCollector<A,​B,​?,​Result> sum​(BiFunction<? super A,​? super B,​Result> groupValueMapping,
Result zero,
BinaryOperator<Result> subtractor)```
• #### sumBigDecimal

`public static <A,​B> BiConstraintCollector<A,​B,​?,​BigDecimal> sumBigDecimal​(BiFunction<? super A,​? super B,​BigDecimal> groupValueMapping)`
• #### sumBigInteger

`public static <A,​B> BiConstraintCollector<A,​B,​?,​BigInteger> sumBigInteger​(BiFunction<? super A,​? super B,​BigInteger> groupValueMapping)`
• #### sumDuration

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Duration> sumDuration​(BiFunction<? super A,​? super B,​Duration> groupValueMapping)`
• #### sumPeriod

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Period> sumPeriod​(BiFunction<? super A,​? super B,​Period> groupValueMapping)`
• #### sum

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer> sum​(ToIntTriFunction<? super A,​? super B,​? super C> groupValueMapping)`
• #### sumLong

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long> sumLong​(ToLongTriFunction<? super A,​? super B,​? super C> groupValueMapping)`
• #### sum

```public static <A,​B,​C,​Result> TriConstraintCollector<A,​B,​C,​?,​Result> sum​(TriFunction<? super A,​? super B,​? super C,​Result> groupValueMapping,
Result zero,
BinaryOperator<Result> subtractor)```
• #### sumBigDecimal

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​BigDecimal> sumBigDecimal​(TriFunction<? super A,​? super B,​? super C,​BigDecimal> groupValueMapping)`
• #### sumBigInteger

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​BigInteger> sumBigInteger​(TriFunction<? super A,​? super B,​? super C,​BigInteger> groupValueMapping)`
• #### sumDuration

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Duration> sumDuration​(TriFunction<? super A,​? super B,​? super C,​Duration> groupValueMapping)`
• #### sumPeriod

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Period> sumPeriod​(TriFunction<? super A,​? super B,​? super C,​Period> groupValueMapping)`
• #### sum

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer> sum​(ToIntQuadFunction<? super A,​? super B,​? super C,​? super D> groupValueMapping)`
• #### sumLong

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long> sumLong​(ToLongQuadFunction<? super A,​? super B,​? super C,​? super D> groupValueMapping)`
• #### sum

```public static <A,​B,​C,​D,​Result> QuadConstraintCollector<A,​B,​C,​D,​?,​Result> sum​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Result> groupValueMapping,
Result zero,
BinaryOperator<Result> subtractor)```
• #### sumBigDecimal

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​BigDecimal> sumBigDecimal​(QuadFunction<? super A,​? super B,​? super C,​? super D,​BigDecimal> groupValueMapping)`
• #### sumBigInteger

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​BigInteger> sumBigInteger​(QuadFunction<? super A,​? super B,​? super C,​? super D,​BigInteger> groupValueMapping)`
• #### sumDuration

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Duration> sumDuration​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Duration> groupValueMapping)`
• #### sumPeriod

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Period> sumPeriod​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Period> groupValueMapping)`
• #### min

`public static <A extends Comparable<A>> UniConstraintCollector<A,​?,​A> min()`
Returns a collector that finds a minimum value in a group of `Comparable` elements.

Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that e1.compareTo(e2) == 0 has the same boolean value as e1.equals(e2). In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(min())` returns either `Ann` or `Eric` arbitrarily, assuming the objects are `Comparable` by the `age` field. To avoid this, always end your `Comparator` by an identity comparison, such as `Comparator.comparing(Person::getAge).comparing(Person::getId))`.

The default result of the collector (e.g. when never called) is `null`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### min

`public static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​Mapped> min​(Function<A,​Mapped> groupValueMapping)`
Returns a collector that finds a minimum value in a group of `Comparable` elements.

Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that e1.compareTo(e2) == 0 has the same boolean value as e1.equals(e2). In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(min(Person::getAge))` returns `20`.

The default result of the collector (e.g. when never called) is `null`.

Type Parameters:
`A` - type of the matched fact
`Mapped` - type of the result
Parameters:
`groupValueMapping` - never null, maps facts from the matched type to the result type
Returns:
never null
• #### min

```public static <A,​Mapped> UniConstraintCollector<A,​?,​Mapped> min​(Function<A,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
As defined by `min(Function)`, only with a custom `Comparator`.
• #### min

`public static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​Mapped> min​(BiFunction<A,​B,​Mapped> groupValueMapping)`
• #### min

```public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Mapped> min​(BiFunction<A,​B,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
As defined by `min(Function)`, only with a custom `Comparator`.
• #### min

`public static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Mapped> min​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
• #### min

```public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Mapped> min​(TriFunction<A,​B,​C,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
As defined by `min(Function)`, only with a custom `Comparator`.
• #### min

`public static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped> min​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
• #### min

```public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped> min​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
As defined by `min(Function)`, only with a custom `Comparator`.
• #### max

`public static <A extends Comparable<A>> UniConstraintCollector<A,​?,​A> max()`
Returns a collector that finds a maximum value in a group of `Comparable` elements.

Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that e1.compareTo(e2) == 0 has the same boolean value as e1.equals(e2). In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(max())` returns either `Cathy` or `David` arbitrarily, assuming the objects are `Comparable` by the `age` field. To avoid this, always end your `Comparator` by an identity comparison, such as `Comparator.comparing(Person::getAge).comparing(Person::getId))`.

The default result of the collector (e.g. when never called) is `null`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### max

`public static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​Mapped> max​(Function<A,​Mapped> groupValueMapping)`
Returns a collector that finds a maximum value in a group of `Comparable` elements.

Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that e1.compareTo(e2) == 0 has the same boolean value as e1.equals(e2). In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(max(Person::getAge))` returns `30`.

The default result of the collector (e.g. when never called) is `null`.

Type Parameters:
`A` - type of the matched fact
`Mapped` - type of the result
Parameters:
`groupValueMapping` - never null, maps facts from the matched type to the result type
Returns:
never null
• #### max

```public static <A,​Mapped> UniConstraintCollector<A,​?,​Mapped> max​(Function<A,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
As defined by `max(Function)`, only with a custom `Comparator`.
• #### max

`public static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​Mapped> max​(BiFunction<A,​B,​Mapped> groupValueMapping)`
• #### max

```public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Mapped> max​(BiFunction<A,​B,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
As defined by `max(Function)`, only with a custom `Comparator`.
• #### max

`public static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Mapped> max​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
• #### max

```public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Mapped> max​(TriFunction<A,​B,​C,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
As defined by `max(Function)`, only with a custom `Comparator`.
• #### max

`public static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped> max​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
• #### max

```public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped> max​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
As defined by `max(Function)`, only with a custom `Comparator`.
• #### toCollection

```@Deprecated
public static <A,​Result extends Collection<A>> UniConstraintCollector<A,​?,​Result> toCollection​(IntFunction<Result> collectionFunction)```
Deprecated.
• #### average

`public static <A> UniConstraintCollector<A,​?,​Double> average​(ToIntFunction<A> groupValueMapping)`
Returns a collector that calculates an average of an `int` property of the elements that are being grouped.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(average(Person::getAge))` returns `25`.

The default result of the collector (e.g. when never called) is `null`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### averageLong

`public static <A> UniConstraintCollector<A,​?,​Double> averageLong​(ToLongFunction<A> groupValueMapping)`
• #### averageDuration

`public static <A> UniConstraintCollector<A,​?,​Duration> averageDuration​(Function<A,​Duration> groupValueMapping)`
• #### average

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Double> average​(ToIntBiFunction<A,​B> groupValueMapping)`
• #### averageLong

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Double> averageLong​(ToLongBiFunction<A,​B> groupValueMapping)`
• #### averageBigDecimal

`public static <A,​B> BiConstraintCollector<A,​B,​?,​BigDecimal> averageBigDecimal​(BiFunction<A,​B,​BigDecimal> groupValueMapping)`
• #### averageBigInteger

`public static <A,​B> BiConstraintCollector<A,​B,​?,​BigDecimal> averageBigInteger​(BiFunction<A,​B,​BigInteger> groupValueMapping)`
• #### averageDuration

`public static <A,​B> BiConstraintCollector<A,​B,​?,​Duration> averageDuration​(BiFunction<A,​B,​Duration> groupValueMapping)`
• #### average

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Double> average​(ToIntTriFunction<A,​B,​C> groupValueMapping)`
• #### averageLong

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Double> averageLong​(ToLongTriFunction<A,​B,​C> groupValueMapping)`
• #### averageBigDecimal

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​BigDecimal> averageBigDecimal​(TriFunction<A,​B,​C,​BigDecimal> groupValueMapping)`
• #### averageBigInteger

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​BigDecimal> averageBigInteger​(TriFunction<A,​B,​C,​BigInteger> groupValueMapping)`
• #### averageDuration

`public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Duration> averageDuration​(TriFunction<A,​B,​C,​Duration> groupValueMapping)`
• #### average

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Double> average​(ToIntQuadFunction<A,​B,​C,​D> groupValueMapping)`
• #### averageLong

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Double> averageLong​(ToLongQuadFunction<A,​B,​C,​D> groupValueMapping)`
• #### averageBigDecimal

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​BigDecimal> averageBigDecimal​(QuadFunction<A,​B,​C,​D,​BigDecimal> groupValueMapping)`
• #### averageBigInteger

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​BigDecimal> averageBigInteger​(QuadFunction<A,​B,​C,​D,​BigInteger> groupValueMapping)`
• #### averageDuration

`public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Duration> averageDuration​(QuadFunction<A,​B,​C,​D,​Duration> groupValueMapping)`
• #### toSet

`public static <A> UniConstraintCollector<A,​?,​Set<A>> toSet()`
Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.

The default result of the collector (e.g. when never called) is an empty `Set`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### toSortedSet

`public static <A extends Comparable<A>> UniConstraintCollector<A,​?,​SortedSet<A>> toSortedSet()`
Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.

The default result of the collector (e.g. when never called) is an empty `SortedSet`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### toList

`public static <A> UniConstraintCollector<A,​?,​List<A>> toList()`
Creates constraint collector that returns `List` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.

The default result of the collector (e.g. when never called) is an empty `List`.

Type Parameters:
`A` - type of the matched fact
Returns:
never null
• #### toCollection

```@Deprecated
public static <A,​Mapped,​Result extends Collection<Mapped>> UniConstraintCollector<A,​?,​Result> toCollection​(Function<A,​Mapped> groupValueMapping,
IntFunction<Result> collectionFunction)```
Deprecated.
• #### toSet

`public static <A,​Mapped> UniConstraintCollector<A,​?,​Set<Mapped>> toSet​(Function<A,​Mapped> groupValueMapping)`
Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.

The default result of the collector (e.g. when never called) is an empty `Set`.

Type Parameters:
`A` - type of the matched fact
`Mapped` - type of elements in the resulting set
Parameters:
`groupValueMapping` - never null, converts matched facts to elements of the resulting set
Returns:
never null
• #### toSortedSet

`public static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​SortedSet<Mapped>> toSortedSet​(Function<A,​Mapped> groupValueMapping)`
Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.

The default result of the collector (e.g. when never called) is an empty `SortedSet`.

Type Parameters:
`A` - type of the matched fact
`Mapped` - type of elements in the resulting set
Parameters:
`groupValueMapping` - never null, converts matched facts to elements of the resulting set
Returns:
never null
• #### toSortedSet

```public static <A,​Mapped> UniConstraintCollector<A,​?,​SortedSet<Mapped>> toSortedSet​(Function<A,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
• #### toList

`public static <A,​Mapped> UniConstraintCollector<A,​?,​List<Mapped>> toList​(Function<A,​Mapped> groupValueMapping)`
Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(Function)`.

The default result of the collector (e.g. when never called) is an empty `List`.

Type Parameters:
`A` - type of the matched fact
`Mapped` - type of elements in the resulting collection
Parameters:
`groupValueMapping` - never null, converts matched facts to elements of the resulting collection
Returns:
never null
• #### toCollection

```@Deprecated
public static <A,​B,​Mapped,​Result extends Collection<Mapped>> BiConstraintCollector<A,​B,​?,​Result> toCollection​(BiFunction<A,​B,​Mapped> groupValueMapping,
IntFunction<Result> collectionFunction)```
Deprecated.
• #### toSet

`public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Set<Mapped>> toSet​(BiFunction<A,​B,​Mapped> groupValueMapping)`
• #### toSortedSet

`public static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​SortedSet<Mapped>> toSortedSet​(BiFunction<A,​B,​Mapped> groupValueMapping)`
• #### toSortedSet

```public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​SortedSet<Mapped>> toSortedSet​(BiFunction<A,​B,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
• #### toList

`public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​List<Mapped>> toList​(BiFunction<A,​B,​Mapped> groupValueMapping)`
• #### toCollection

```@Deprecated
public static <A,​B,​C,​Mapped,​Result extends Collection<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Result> toCollection​(TriFunction<A,​B,​C,​Mapped> groupValueMapping,
IntFunction<Result> collectionFunction)```
Deprecated.
• #### toSet

`public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Set<Mapped>> toSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
• #### toSortedSet

`public static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​SortedSet<Mapped>> toSortedSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
• #### toSortedSet

```public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​SortedSet<Mapped>> toSortedSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
• #### toList

`public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​List<Mapped>> toList​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)`
• #### toCollection

```@Deprecated
IntFunction<Result> collectionFunction)```
Deprecated.
• #### toSet

`public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Set<Mapped>> toSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
• #### toSortedSet

`public static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedSet<Mapped>> toSortedSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
• #### toSortedSet

```public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedSet<Mapped>> toSortedSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping,
Comparator<Mapped> comparator)```
• #### toList

`public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​List<Mapped>> toList​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)`
• #### toMap

```public static <A,​Key,​Value> UniConstraintCollector<A,​?,​Map<Key,​Set<Value>>> toMap​(Function<? super A,​? extends Key> keyMapper,
Function<? super A,​? extends Value> valueMapper)```
Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

Makes no guarantees on iteration order, neither for map entries, nor for the value sets. For stable iteration order, use `toSortedMap(Function, Function, IntFunction)`.

The default result of the collector (e.g. when never called) is an empty `Map`.

Type Parameters:
`A` - type of the matched fact
`Key` - type of map key
`Value` - type of map value
Parameters:
`keyMapper` - map matched fact to a map key
`valueMapper` - map matched fact to a value
Returns:
never null
• #### toMap

```public static <A,​Key,​Value,​ValueSet extends Set<Value>> UniConstraintCollector<A,​?,​Map<Key,​ValueSet>> toMap​(Function<? super A,​? extends Key> keyMapper,
Function<? super A,​? extends Value> valueMapper,
IntFunction<ValueSet> valueSetFunction)```
Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

Iteration order of value collections depends on the `Set` provided. Makes no guarantees on iteration order for map entries, use `toSortedMap(Function, Function, IntFunction)` for that.

The default result of the collector (e.g. when never called) is an empty `Map`.

Type Parameters:
`A` - type of the matched fact
`Key` - type of map key
`Value` - type of map value
`ValueSet` - type of the value set
Parameters:
`keyMapper` - map matched fact to a map key
`valueMapper` - map matched fact to a value
`valueSetFunction` - creates a set that will be used to store value mappings
Returns:
never null
• #### toMap

```public static <A,​Key,​Value> UniConstraintCollector<A,​?,​Map<Key,​Value>> toMap​(Function<? super A,​? extends Key> keyMapper,
Function<? super A,​? extends Value> valueMapper,
BinaryOperator<Value> mergeFunction)```
Creates a constraint collector that returns a `Map`.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName, (name1, name2) -> name1 + " and " + name2)` returns `{20: "Ann and Eric", 25: "Beth", 30: "Cathy and David"}`.

Makes no guarantees on iteration order for map entries. For stable iteration order, use `toSortedMap(Function, Function, BinaryOperator)`.

The default result of the collector (e.g. when never called) is an empty `Map`.

Type Parameters:
`A` - type of the matched fact
`Key` - type of map key
`Value` - type of map value
Parameters:
`keyMapper` - map matched fact to a map key
`valueMapper` - map matched fact to a value
`mergeFunction` - takes two values and merges them to one
Returns:
never null
• #### toSortedMap

```public static <A,​Key extends Comparable<Key>,​Value> UniConstraintCollector<A,​?,​SortedMap<Key,​Set<Value>>> toSortedMap​(Function<? super A,​? extends Key> keyMapper,
Function<? super A,​? extends Value> valueMapper)```
Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

Makes no guarantees on iteration order for the value sets, use `toSortedMap(Function, Function, IntFunction)` for that.

The default result of the collector (e.g. when never called) is an empty `SortedMap`.

Type Parameters:
`A` - type of the matched fact
`Key` - type of map key
`Value` - type of map value
Parameters:
`keyMapper` - map matched fact to a map key
`valueMapper` - map matched fact to a value
Returns:
never null
• #### toSortedMap

```public static <A,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> UniConstraintCollector<A,​?,​SortedMap<Key,​ValueSet>> toSortedMap​(Function<? super A,​? extends Key> keyMapper,
Function<? super A,​? extends Value> valueMapper,
IntFunction<ValueSet> valueSetFunction)```
Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

Iteration order of value collections depends on the `Set` provided.

The default result of the collector (e.g. when never called) is an empty `SortedMap`.

Type Parameters:
`A` - type of the matched fact
`Key` - type of map key
`Value` - type of map value
`ValueSet` - type of the value set
Parameters:
`keyMapper` - map matched fact to a map key
`valueMapper` - map matched fact to a value
`valueSetFunction` - creates a set that will be used to store value mappings
Returns:
never null
• #### toSortedMap

```public static <A,​Key extends Comparable<Key>,​Value> UniConstraintCollector<A,​?,​SortedMap<Key,​Value>> toSortedMap​(Function<? super A,​? extends Key> keyMapper,
Function<? super A,​? extends Value> valueMapper,
BinaryOperator<Value> mergeFunction)```
Creates a constraint collector that returns a `SortedMap`.

For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName, (name1, name2) -> name1 + " and " + name2)` returns `{20: "Ann and Eric", 25: "Beth", 30: "Cathy and David"}`.

The default result of the collector (e.g. when never called) is an empty `SortedMap`.

Type Parameters:
`A` - type of the matched fact
`Key` - type of map key
`Value` - type of map value
Parameters:
`keyMapper` - map matched fact to a map key
`valueMapper` - map matched fact to a value
`mergeFunction` - takes two values and merges them to one
Returns:
never null
• #### toMap

```public static <A,​B,​Key,​Value> BiConstraintCollector<A,​B,​?,​Map<Key,​Set<Value>>> toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
BiFunction<? super A,​? super B,​? extends Value> valueMapper)```
• #### toMap

```public static <A,​B,​Key,​Value,​ValueSet extends Set<Value>> BiConstraintCollector<A,​B,​?,​Map<Key,​ValueSet>> toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
BiFunction<? super A,​? super B,​? extends Value> valueMapper,
IntFunction<ValueSet> valueSetFunction)```
• #### toMap

```public static <A,​B,​Key,​Value> BiConstraintCollector<A,​B,​?,​Map<Key,​Value>> toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
BiFunction<? super A,​? super B,​? extends Value> valueMapper,
BinaryOperator<Value> mergeFunction)```
• #### toSortedMap

```public static <A,​B,​Key extends Comparable<Key>,​Value> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​Set<Value>>> toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
BiFunction<? super A,​? super B,​? extends Value> valueMapper)```
• #### toSortedMap

```public static <A,​B,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​ValueSet>> toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
BiFunction<? super A,​? super B,​? extends Value> valueMapper,
IntFunction<ValueSet> valueSetFunction)```
• #### toSortedMap

```public static <A,​B,​Key extends Comparable<Key>,​Value> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​Value>> toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
BiFunction<? super A,​? super B,​? extends Value> valueMapper,
BinaryOperator<Value> mergeFunction)```
• #### toMap

```public static <A,​B,​C,​Key,​Value> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​Set<Value>>> toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper)```
• #### toMap

```public static <A,​B,​C,​Key,​Value,​ValueSet extends Set<Value>> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​ValueSet>> toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper,
IntFunction<ValueSet> valueSetFunction)```
• #### toMap

```public static <A,​B,​C,​Key,​Value> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​Value>> toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper,
BinaryOperator<Value> mergeFunction)```
• #### toSortedMap

```public static <A,​B,​C,​Key extends Comparable<Key>,​Value> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​Set<Value>>> toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper)```
• #### toSortedMap

```public static <A,​B,​C,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​ValueSet>> toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper,
IntFunction<ValueSet> valueSetFunction)```
• #### toSortedMap

```public static <A,​B,​C,​Key extends Comparable<Key>,​Value> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​Value>> toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper,
BinaryOperator<Value> mergeFunction)```
• #### toMap

```public static <A,​B,​C,​D,​Key,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​Set<Value>>> toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper)```
• #### toMap

```public static <A,​B,​C,​D,​Key,​Value,​ValueSet extends Set<Value>> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​ValueSet>> toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper,
IntFunction<ValueSet> valueSetFunction)```
• #### toMap

```public static <A,​B,​C,​D,​Key,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​Value>> toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper,
BinaryOperator<Value> mergeFunction)```
• #### toSortedMap

```public static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​Set<Value>>> toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper)```
• #### toSortedMap

```public static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​ValueSet>> toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper,
IntFunction<ValueSet> valueSetFunction)```
• #### toSortedMap

```public static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​Value>> toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper,
BinaryOperator<Value> mergeFunction)```
• #### conditionally

```public static <A,​ResultContainer_,​Result_> UniConstraintCollector<A,​ResultContainer_,​Result_> conditionally​(Predicate<A> condition,
UniConstraintCollector<A,​ResultContainer_,​Result_> delegate)```
Returns a collector that delegates to the underlying collector if and only if the input tuple meets the given condition.

The result of the collector is always the underlying collector's result. Therefore the default result of the collector (e.g. when never called) is the default result of the underlying collector.

Type Parameters:
`A` - generic type of the tuple variable
`ResultContainer_` - generic type of the result container
`Result_` - generic type of the collector's return value
Parameters:
`condition` - never null, condition to meet in order to delegate to the underlying collector
`delegate` - never null, the underlying collector to delegate to
Returns:
never null
• #### conditionally

```public static <A,​B,​ResultContainer_,​Result_> BiConstraintCollector<A,​B,​ResultContainer_,​Result_> conditionally​(BiPredicate<A,​B> condition,
BiConstraintCollector<A,​B,​ResultContainer_,​Result_> delegate)```
• #### conditionally

```public static <A,​B,​C,​ResultContainer_,​Result_> TriConstraintCollector<A,​B,​C,​ResultContainer_,​Result_> conditionally​(TriPredicate<A,​B,​C> condition,
TriConstraintCollector<A,​B,​C,​ResultContainer_,​Result_> delegate)```
• #### conditionally

```public static <A,​B,​C,​D,​ResultContainer_,​Result_> QuadConstraintCollector<A,​B,​C,​D,​ResultContainer_,​Result_> conditionally​(QuadPredicate<A,​B,​C,​D> condition,
• #### compose

```public static <A,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResult1_,​SubResult2_> UniConstraintCollector<A,​?,​Result_> compose​(UniConstraintCollector<A,​SubResultContainer1_,​SubResult1_> subCollector1,
UniConstraintCollector<A,​SubResultContainer2_,​SubResult2_> subCollector2,
BiFunction<SubResult1_,​SubResult2_,​Result_> composeFunction)```
Returns a constraint collector the result of which is a composition of other constraint collectors. The return value of this collector, incl. the default return value, depends solely on the compose function.
Type Parameters:
`A` - generic type of the tuple variable
`Result_` - generic type of the parent collector's return value
`SubResultContainer1_` - generic type of the first sub collector's result container
`SubResultContainer2_` - generic type of the second sub collector's result container
`SubResult1_` - generic type of the first sub collector's return value
`SubResult2_` - generic type of the second sub collector's return value
Parameters:
`subCollector1` - never null, first collector to compose
`subCollector2` - never null, second collector to compose
`composeFunction` - never null, turns results of the sub collectors to a result of the parent collector
Returns:
never null
• #### compose

```public static <A,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResult1_,​SubResult2_,​SubResult3_> UniConstraintCollector<A,​?,​Result_> compose​(UniConstraintCollector<A,​SubResultContainer1_,​SubResult1_> subCollector1,
UniConstraintCollector<A,​SubResultContainer2_,​SubResult2_> subCollector2,
UniConstraintCollector<A,​SubResultContainer3_,​SubResult3_> subCollector3,
TriFunction<SubResult1_,​SubResult2_,​SubResult3_,​Result_> composeFunction)```
Returns a constraint collector the result of which is a composition of other constraint collectors. The return value of this collector, incl. the default return value, depends solely on the compose function.
Type Parameters:
`A` - generic type of the tuple variable
`Result_` - generic type of the parent collector's return value
`SubResultContainer1_` - generic type of the first sub collector's result container
`SubResultContainer2_` - generic type of the second sub collector's result container
`SubResultContainer3_` - generic type of the third sub collector's result container
`SubResult1_` - generic type of the first sub collector's return value
`SubResult2_` - generic type of the second sub collector's return value
`SubResult3_` - generic type of the third sub collector's return value
Parameters:
`subCollector1` - never null, first collector to compose
`subCollector2` - never null, second collector to compose
`subCollector3` - never null, third collector to compose
`composeFunction` - never null, turns results of the sub collectors to a result of the parent collector
Returns:
never null
• #### compose

```public static <A,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResultContainer4_,​SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_> UniConstraintCollector<A,​?,​Result_> compose​(UniConstraintCollector<A,​SubResultContainer1_,​SubResult1_> subCollector1,
UniConstraintCollector<A,​SubResultContainer2_,​SubResult2_> subCollector2,
UniConstraintCollector<A,​SubResultContainer3_,​SubResult3_> subCollector3,
UniConstraintCollector<A,​SubResultContainer4_,​SubResult4_> subCollector4,
Returns a constraint collector the result of which is a composition of other constraint collectors. The return value of this collector, incl. the default return value, depends solely on the compose function.
Type Parameters:
`A` - generic type of the tuple variable
`Result_` - generic type of the parent collector's return value
`SubResultContainer1_` - generic type of the first sub collector's result container
`SubResultContainer2_` - generic type of the second sub collector's result container
`SubResultContainer3_` - generic type of the third sub collector's result container
`SubResultContainer4_` - generic type of the fourth sub collector's result container
`SubResult1_` - generic type of the first sub collector's return value
`SubResult2_` - generic type of the second sub collector's return value
`SubResult3_` - generic type of the third sub collector's return value
`SubResult4_` - generic type of the fourth sub collector's return value
Parameters:
`subCollector1` - never null, first collector to compose
`subCollector2` - never null, second collector to compose
`subCollector3` - never null, third collector to compose
`subCollector4` - never null, fourth collector to compose
`composeFunction` - never null, turns results of the sub collectors to a result of the parent collector
Returns:
never null
• #### compose

```public static <A,​B,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResult1_,​SubResult2_> BiConstraintCollector<A,​B,​?,​Result_> compose​(BiConstraintCollector<A,​B,​SubResultContainer1_,​SubResult1_> subCollector1,
BiConstraintCollector<A,​B,​SubResultContainer2_,​SubResult2_> subCollector2,
BiFunction<SubResult1_,​SubResult2_,​Result_> composeFunction)```
• #### compose

```public static <A,​B,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResult1_,​SubResult2_,​SubResult3_> BiConstraintCollector<A,​B,​?,​Result_> compose​(BiConstraintCollector<A,​B,​SubResultContainer1_,​SubResult1_> subCollector1,
BiConstraintCollector<A,​B,​SubResultContainer2_,​SubResult2_> subCollector2,
BiConstraintCollector<A,​B,​SubResultContainer3_,​SubResult3_> subCollector3,
TriFunction<SubResult1_,​SubResult2_,​SubResult3_,​Result_> composeFunction)```
• #### compose

```public static <A,​B,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResultContainer4_,​SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_> BiConstraintCollector<A,​B,​?,​Result_> compose​(BiConstraintCollector<A,​B,​SubResultContainer1_,​SubResult1_> subCollector1,
BiConstraintCollector<A,​B,​SubResultContainer2_,​SubResult2_> subCollector2,
BiConstraintCollector<A,​B,​SubResultContainer3_,​SubResult3_> subCollector3,
BiConstraintCollector<A,​B,​SubResultContainer4_,​SubResult4_> subCollector4,
• #### compose

```public static <A,​B,​C,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResult1_,​SubResult2_> TriConstraintCollector<A,​B,​C,​?,​Result_> compose​(TriConstraintCollector<A,​B,​C,​SubResultContainer1_,​SubResult1_> subCollector1,
TriConstraintCollector<A,​B,​C,​SubResultContainer2_,​SubResult2_> subCollector2,
BiFunction<SubResult1_,​SubResult2_,​Result_> composeFunction)```
• #### compose

```public static <A,​B,​C,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResult1_,​SubResult2_,​SubResult3_> TriConstraintCollector<A,​B,​C,​?,​Result_> compose​(TriConstraintCollector<A,​B,​C,​SubResultContainer1_,​SubResult1_> subCollector1,
TriConstraintCollector<A,​B,​C,​SubResultContainer2_,​SubResult2_> subCollector2,
TriConstraintCollector<A,​B,​C,​SubResultContainer3_,​SubResult3_> subCollector3,
TriFunction<SubResult1_,​SubResult2_,​SubResult3_,​Result_> composeFunction)```
• #### compose

```public static <A,​B,​C,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResultContainer4_,​SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_> TriConstraintCollector<A,​B,​C,​?,​Result_> compose​(TriConstraintCollector<A,​B,​C,​SubResultContainer1_,​SubResult1_> subCollector1,
TriConstraintCollector<A,​B,​C,​SubResultContainer2_,​SubResult2_> subCollector2,
TriConstraintCollector<A,​B,​C,​SubResultContainer3_,​SubResult3_> subCollector3,
TriConstraintCollector<A,​B,​C,​SubResultContainer4_,​SubResult4_> subCollector4,
• #### compose

```public static <A,​B,​C,​D,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResult1_,​SubResult2_> QuadConstraintCollector<A,​B,​C,​D,​?,​Result_> compose​(QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer1_,​SubResult1_> subCollector1,
BiFunction<SubResult1_,​SubResult2_,​Result_> composeFunction)```
• #### compose

```public static <A,​B,​C,​D,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResult1_,​SubResult2_,​SubResult3_> QuadConstraintCollector<A,​B,​C,​D,​?,​Result_> compose​(QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer1_,​SubResult1_> subCollector1,
```public static <A,​B,​C,​D,​Result_,​SubResultContainer1_,​SubResultContainer2_,​SubResultContainer3_,​SubResultContainer4_,​SubResult1_,​SubResult2_,​SubResult3_,​SubResult4_> QuadConstraintCollector<A,​B,​C,​D,​?,​Result_> compose​(QuadConstraintCollector<A,​B,​C,​D,​SubResultContainer1_,​SubResult1_> subCollector1,