Interface Collectable<T>

    • Method Summary

      All Methods Instance Methods Abstract Methods Default Methods 
      Modifier and Type Method Description
      boolean allMatch​(java.util.function.Predicate<? super T> predicate)
      Whether all elements in the collectable match a given predicate.
      boolean anyMatch​(java.util.function.Predicate<? super T> predicate)
      Whether any element in the collectable matches a given predicate.
      java.util.Optional<T> avg()
      Get the average of the elements in this collectable.
      <U> java.util.Optional<U> avg​(java.util.function.Function<? super T,​? extends U> function)
      Get the average of the elements in this collectable.
      double avgDouble​(java.util.function.ToDoubleFunction<? super T> function)
      Get the average of the elements in this collectable as double.
      double avgInt​(java.util.function.ToIntFunction<? super T> function)
      Get the average of the elements in this collectable as int.
      double avgLong​(java.util.function.ToLongFunction<? super T> function)
      Get the average of the elements in this collectable as long.
      java.util.Optional<T> bitAnd()
      Collect all bits in this stream into a single value by applying bitwise and.
      <U> java.util.Optional<U> bitAnd​(java.util.function.Function<? super T,​? extends U> function)
      Collect all bits in this stream into a single value by applying bitwise and.
      int bitAndInt​(java.util.function.ToIntFunction<? super T> function)
      Collect all bits in this stream into a single value by applying bitwise and.
      long bitAndLong​(java.util.function.ToLongFunction<? super T> function)
      Collect all bits in this stream into a single value by applying bitwise and.
      java.util.Optional<T> bitOr()
      Collect all bits in this stream into a single value by applying bitwise or.
      <U> java.util.Optional<U> bitOr​(java.util.function.Function<? super T,​? extends U> function)
      Collect all bits in this stream into a single value by applying bitwise or.
      int bitOrInt​(java.util.function.ToIntFunction<? super T> function)
      Collect all bits in this stream into a single value by applying bitwise or.
      long bitOrLong​(java.util.function.ToLongFunction<? super T> function)
      Collect all bits in this stream into a single value by applying bitwise or.
      <R,​A>
      R
      collect​(java.util.stream.Collector<? super T,​A,​R> collector)
      Collect this collectable.
      default <R1,​R2,​A1,​A2>
      Tuple2<R1,​R2>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2)
      Collect this collectable into 2 Collectors.
      default <R1,​R2,​R3,​A1,​A2,​A3>
      Tuple3<R1,​R2,​R3>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3)
      Collect this collectable into 3 Collectors.
      default <R1,​R2,​R3,​R4,​A1,​A2,​A3,​A4>
      Tuple4<R1,​R2,​R3,​R4>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4)
      Collect this collectable into 4 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​A1,​A2,​A3,​A4,​A5>
      Tuple5<R1,​R2,​R3,​R4,​R5>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5)
      Collect this collectable into 5 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​A1,​A2,​A3,​A4,​A5,​A6>
      Tuple6<R1,​R2,​R3,​R4,​R5,​R6>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6)
      Collect this collectable into 6 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​A1,​A2,​A3,​A4,​A5,​A6,​A7>
      Tuple7<R1,​R2,​R3,​R4,​R5,​R6,​R7>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7)
      Collect this collectable into 7 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8>
      Tuple8<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8)
      Collect this collectable into 8 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9>
      Tuple9<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8, java.util.stream.Collector<? super T,​A9,​R9> collector9)
      Collect this collectable into 9 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10>
      Tuple10<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8, java.util.stream.Collector<? super T,​A9,​R9> collector9, java.util.stream.Collector<? super T,​A10,​R10> collector10)
      Collect this collectable into 10 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11>
      Tuple11<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8, java.util.stream.Collector<? super T,​A9,​R9> collector9, java.util.stream.Collector<? super T,​A10,​R10> collector10, java.util.stream.Collector<? super T,​A11,​R11> collector11)
      Collect this collectable into 11 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12>
      Tuple12<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8, java.util.stream.Collector<? super T,​A9,​R9> collector9, java.util.stream.Collector<? super T,​A10,​R10> collector10, java.util.stream.Collector<? super T,​A11,​R11> collector11, java.util.stream.Collector<? super T,​A12,​R12> collector12)
      Collect this collectable into 12 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13>
      Tuple13<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8, java.util.stream.Collector<? super T,​A9,​R9> collector9, java.util.stream.Collector<? super T,​A10,​R10> collector10, java.util.stream.Collector<? super T,​A11,​R11> collector11, java.util.stream.Collector<? super T,​A12,​R12> collector12, java.util.stream.Collector<? super T,​A13,​R13> collector13)
      Collect this collectable into 13 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14>
      Tuple14<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8, java.util.stream.Collector<? super T,​A9,​R9> collector9, java.util.stream.Collector<? super T,​A10,​R10> collector10, java.util.stream.Collector<? super T,​A11,​R11> collector11, java.util.stream.Collector<? super T,​A12,​R12> collector12, java.util.stream.Collector<? super T,​A13,​R13> collector13, java.util.stream.Collector<? super T,​A14,​R14> collector14)
      Collect this collectable into 14 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​R15,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15>
      Tuple15<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​R15>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8, java.util.stream.Collector<? super T,​A9,​R9> collector9, java.util.stream.Collector<? super T,​A10,​R10> collector10, java.util.stream.Collector<? super T,​A11,​R11> collector11, java.util.stream.Collector<? super T,​A12,​R12> collector12, java.util.stream.Collector<? super T,​A13,​R13> collector13, java.util.stream.Collector<? super T,​A14,​R14> collector14, java.util.stream.Collector<? super T,​A15,​R15> collector15)
      Collect this collectable into 15 Collectors.
      default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​R15,​R16,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15,​A16>
      Tuple16<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​R15,​R16>
      collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1, java.util.stream.Collector<? super T,​A2,​R2> collector2, java.util.stream.Collector<? super T,​A3,​R3> collector3, java.util.stream.Collector<? super T,​A4,​R4> collector4, java.util.stream.Collector<? super T,​A5,​R5> collector5, java.util.stream.Collector<? super T,​A6,​R6> collector6, java.util.stream.Collector<? super T,​A7,​R7> collector7, java.util.stream.Collector<? super T,​A8,​R8> collector8, java.util.stream.Collector<? super T,​A9,​R9> collector9, java.util.stream.Collector<? super T,​A10,​R10> collector10, java.util.stream.Collector<? super T,​A11,​R11> collector11, java.util.stream.Collector<? super T,​A12,​R12> collector12, java.util.stream.Collector<? super T,​A13,​R13> collector13, java.util.stream.Collector<? super T,​A14,​R14> collector14, java.util.stream.Collector<? super T,​A15,​R15> collector15, java.util.stream.Collector<? super T,​A16,​R16> collector16)
      Collect this collectable into 16 Collectors.
      java.lang.String commonPrefix()
      Get the common prefix of all strings (or to-stringed values) in this stream.
      java.lang.String commonSuffix()
      Get the common prefix of all strings (or to-stringed values) in this stream.
      long count()
      Count the values in this collectable.
      long count​(java.util.function.Predicate<? super T> predicate)
      Count the values in this collectable, for which a predicate evaluates to true.
      long countDistinct()
      Count the distinct values in this collectable.
      long countDistinct​(java.util.function.Predicate<? super T> predicate)
      Count the distinct values in this collectable, for which a predicate evaluates to true.
      <U> long countDistinctBy​(java.util.function.Function<? super T,​? extends U> function)
      Count the distinct values of a given expression in this collectable.
      <U> long countDistinctBy​(java.util.function.Function<? super T,​? extends U> function, java.util.function.Predicate<? super U> predicate)
      Count the distinct values of a given expression in this collectable, for which a predicate evaluates to true.
      java.util.Optional<T> max()
      Get the maximum value.
      java.util.Optional<T> max​(java.util.Comparator<? super T> comparator)
      Get the maximum value by a function.
      <U extends java.lang.Comparable<? super U>>
      java.util.Optional<U>
      max​(java.util.function.Function<? super T,​? extends U> function)
      Get the maximum value by a function.
      <U> java.util.Optional<U> max​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the maximum value by a function.
      Seq<T> maxAll()
      Get the maximum values.
      Seq<T> maxAll​(java.util.Comparator<? super T> comparator)
      Get the maximum values by a function.
      <U extends java.lang.Comparable<? super U>>
      Seq<U>
      maxAll​(java.util.function.Function<? super T,​? extends U> function)
      Get the maximum values by a function.
      <U> Seq<U> maxAll​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the maximum values by a function.
      <U extends java.lang.Comparable<? super U>>
      Seq<T>
      maxAllBy​(java.util.function.Function<? super T,​? extends U> function)
      Get the maximum values by a function.
      <U> Seq<T> maxAllBy​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the maximum values by a function.
      <U extends java.lang.Comparable<? super U>>
      java.util.Optional<T>
      maxBy​(java.util.function.Function<? super T,​? extends U> function)
      Get the maximum value by a function.
      <U> java.util.Optional<T> maxBy​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the maximum value by a function.
      java.util.Optional<T> median()
      Get the median value.
      java.util.Optional<T> median​(java.util.Comparator<? super T> comparator)
      Get the median value.
      <U extends java.lang.Comparable<? super U>>
      java.util.Optional<T>
      medianBy​(java.util.function.Function<? super T,​? extends U> function)
      Get the median value by a function.
      <U> java.util.Optional<T> medianBy​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the median value by a function.
      java.util.Optional<T> min()
      Get the minimum value.
      java.util.Optional<T> min​(java.util.Comparator<? super T> comparator)
      Get the minimum value by a function.
      <U extends java.lang.Comparable<? super U>>
      java.util.Optional<U>
      min​(java.util.function.Function<? super T,​? extends U> function)
      Get the minimum value by a function.
      <U> java.util.Optional<U> min​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the minimum value by a function.
      Seq<T> minAll()
      Get the minimum values.
      Seq<T> minAll​(java.util.Comparator<? super T> comparator)
      Get the minimum values by a function.
      <U extends java.lang.Comparable<? super U>>
      Seq<U>
      minAll​(java.util.function.Function<? super T,​? extends U> function)
      Get the minimum values by a function.
      <U> Seq<U> minAll​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the minimum values by a function.
      <U extends java.lang.Comparable<? super U>>
      Seq<T>
      minAllBy​(java.util.function.Function<? super T,​? extends U> function)
      Get the minimum values by a function.
      <U> Seq<T> minAllBy​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the minimum values by a function.
      <U extends java.lang.Comparable<? super U>>
      java.util.Optional<T>
      minBy​(java.util.function.Function<? super T,​? extends U> function)
      Get the minimum value by a function.
      <U> java.util.Optional<T> minBy​(java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the minimum value by a function.
      java.util.Optional<T> mode()
      Get the mode, i.e.
      Seq<T> modeAll()
      Get the mode, i.e.
      <U> Seq<T> modeAllBy​(java.util.function.Function<? super T,​? extends U> function)
      Get the mode, i.e.
      <U> java.util.Optional<T> modeBy​(java.util.function.Function<? super T,​? extends U> function)
      Get the mode, i.e.
      boolean noneMatch​(java.util.function.Predicate<? super T> predicate)
      Whether no element in the collectable matches a given predicate.
      java.util.Optional<T> percentile​(double percentile)
      Get the discrete percentile value.
      java.util.Optional<T> percentile​(double percentile, java.util.Comparator<? super T> comparator)
      Get the discrete percentile value.
      <U extends java.lang.Comparable<? super U>>
      java.util.Optional<T>
      percentileBy​(double percentile, java.util.function.Function<? super T,​? extends U> function)
      Get the discrete percentile value by a function.
      <U> java.util.Optional<T> percentileBy​(double percentile, java.util.function.Function<? super T,​? extends U> function, java.util.Comparator<? super U> comparator)
      Get the discrete percentile value by a function.
      java.util.Optional<T> sum()
      Get the sum of the elements in this collectable.
      <U> java.util.Optional<U> sum​(java.util.function.Function<? super T,​? extends U> function)
      Get the sum of the elements in this collectable.
      double sumDouble​(java.util.function.ToDoubleFunction<? super T> function)
      Get the sum of the elements in this collectable as double.
      int sumInt​(java.util.function.ToIntFunction<? super T> function)
      Get the sum of the elements in this collectable as int.
      long sumLong​(java.util.function.ToLongFunction<? super T> function)
      Get the sum of the elements in this collectable as long.
      <C extends java.util.Collection<T>>
      C
      toCollection​(java.util.function.Supplier<C> factory)
      Collect the collectable into a Collection.
      java.util.List<T> toList()
      Collect the collectable into an ArrayList.
      <L extends java.util.List<T>>
      L
      toList​(java.util.function.Supplier<L> factory)
      Collect the collectable into a List.
      <K> java.util.Map<K,​T> toMap​(java.util.function.Function<? super T,​? extends K> keyMapper)
      Collect the collectable into a Map with the given keys and the self element as value.
      <K,​V>
      java.util.Map<K,​V>
      toMap​(java.util.function.Function<? super T,​? extends K> keyMapper, java.util.function.Function<? super T,​? extends V> valueMapper)
      Collect the collectable into a Map.
      java.util.Set<T> toSet()
      Collect the collectable into a LinkedHashSet.
      <S extends java.util.Set<T>>
      S
      toSet​(java.util.function.Supplier<S> factory)
      Collect the collectable into a Set.
      java.lang.String toString​(java.lang.CharSequence delimiter)
      Consume a stream and concatenate all elements using a separator.
      java.lang.String toString​(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix)
      Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence, CharSequence, CharSequence) collector.
      java.util.List<T> toUnmodifiableList()
      Collect the collectable into an unmodifiable List.
      java.util.Set<T> toUnmodifiableSet()
      Collect the collectable into an unmodifiable Set.
    • Method Detail

      • collect

        <R,​A> R collect​(java.util.stream.Collector<? super T,​A,​R> collector)
        Collect this collectable.
      • collect

        default <R1,​R2,​A1,​A2> Tuple2<R1,​R2> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                            java.util.stream.Collector<? super T,​A2,​R2> collector2)
        Collect this collectable into 2 Collectors.
      • collect

        default <R1,​R2,​R3,​A1,​A2,​A3> Tuple3<R1,​R2,​R3> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                       java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                       java.util.stream.Collector<? super T,​A3,​R3> collector3)
        Collect this collectable into 3 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​A1,​A2,​A3,​A4> Tuple4<R1,​R2,​R3,​R4> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                  java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                  java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                  java.util.stream.Collector<? super T,​A4,​R4> collector4)
        Collect this collectable into 4 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​A1,​A2,​A3,​A4,​A5> Tuple5<R1,​R2,​R3,​R4,​R5> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                             java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                             java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                             java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                             java.util.stream.Collector<? super T,​A5,​R5> collector5)
        Collect this collectable into 5 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​A1,​A2,​A3,​A4,​A5,​A6> Tuple6<R1,​R2,​R3,​R4,​R5,​R6> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                        java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                        java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                        java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                        java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                        java.util.stream.Collector<? super T,​A6,​R6> collector6)
        Collect this collectable into 6 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​A1,​A2,​A3,​A4,​A5,​A6,​A7> Tuple7<R1,​R2,​R3,​R4,​R5,​R6,​R7> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                   java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                   java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                   java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                   java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                   java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                   java.util.stream.Collector<? super T,​A7,​R7> collector7)
        Collect this collectable into 7 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8> Tuple8<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A8,​R8> collector8)
        Collect this collectable into 8 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9> Tuple9<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                                                         java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                                                         java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                                                         java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                                                         java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                                                         java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                                                         java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                                                         java.util.stream.Collector<? super T,​A8,​R8> collector8,
                                                                                                                                                                                                                                                                         java.util.stream.Collector<? super T,​A9,​R9> collector9)
        Collect this collectable into 9 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10> Tuple10<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A8,​R8> collector8,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A9,​R9> collector9,
                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A10,​R10> collector10)
        Collect this collectable into 10 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11> Tuple11<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A8,​R8> collector8,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A9,​R9> collector9,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A10,​R10> collector10,
                                                                                                                                                                                                                                                                                                                                      java.util.stream.Collector<? super T,​A11,​R11> collector11)
        Collect this collectable into 11 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12> Tuple12<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A8,​R8> collector8,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A9,​R9> collector9,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A10,​R10> collector10,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A11,​R11> collector11,
                                                                                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A12,​R12> collector12)
        Collect this collectable into 12 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13> Tuple13<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A8,​R8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A9,​R9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A10,​R10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A11,​R11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A12,​R12> collector12,
                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A13,​R13> collector13)
        Collect this collectable into 13 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14> Tuple14<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A8,​R8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A9,​R9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A10,​R10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A11,​R11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A12,​R12> collector12,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A13,​R13> collector13,
                                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A14,​R14> collector14)
        Collect this collectable into 14 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​R15,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15> Tuple15<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​R15> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A8,​R8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A9,​R9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A10,​R10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A11,​R11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A12,​R12> collector12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A13,​R13> collector13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A14,​R14> collector14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.stream.Collector<? super T,​A15,​R15> collector15)
        Collect this collectable into 15 Collectors.
      • collect

        default <R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​R15,​R16,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15,​A16> Tuple16<R1,​R2,​R3,​R4,​R5,​R6,​R7,​R8,​R9,​R10,​R11,​R12,​R13,​R14,​R15,​R16> collect​(java.util.stream.Collector<? super T,​A1,​R1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A2,​R2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A3,​R3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A4,​R4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A5,​R5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A6,​R6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A7,​R7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A8,​R8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A9,​R9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A10,​R10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A11,​R11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A12,​R12> collector12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A13,​R13> collector13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A14,​R14> collector14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A15,​R15> collector15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A16,​R16> collector16)
        Collect this collectable into 16 Collectors.
      • count

        long count()
        Count the values in this collectable.
      • count

        long count​(java.util.function.Predicate<? super T> predicate)
        Count the values in this collectable, for which a predicate evaluates to true.
      • countDistinct

        long countDistinct()
        Count the distinct values in this collectable.
      • countDistinct

        long countDistinct​(java.util.function.Predicate<? super T> predicate)
        Count the distinct values in this collectable, for which a predicate evaluates to true.
      • countDistinctBy

        <U> long countDistinctBy​(java.util.function.Function<? super T,​? extends U> function)
        Count the distinct values of a given expression in this collectable.
      • countDistinctBy

        <U> long countDistinctBy​(java.util.function.Function<? super T,​? extends U> function,
                                 java.util.function.Predicate<? super U> predicate)
        Count the distinct values of a given expression in this collectable, for which a predicate evaluates to true.
      • mode

        java.util.Optional<T> mode()
        Get the mode, i.e. the value that appears most often in the collectable.
      • modeBy

        <U> java.util.Optional<T> modeBy​(java.util.function.Function<? super T,​? extends U> function)
        Get the mode, i.e. the value that appears most often in the collectable.
      • modeAll

        Seq<T> modeAll()
        Get the mode, i.e. the values that appear most often in the collectable.
      • modeAllBy

        <U> Seq<T> modeAllBy​(java.util.function.Function<? super T,​? extends U> function)
        Get the mode, i.e. the values that appear most often in the collectable.
      • sum

        java.util.Optional<T> sum()
        Get the sum of the elements in this collectable.
      • sum

        <U> java.util.Optional<U> sum​(java.util.function.Function<? super T,​? extends U> function)
        Get the sum of the elements in this collectable.
      • sumInt

        int sumInt​(java.util.function.ToIntFunction<? super T> function)
        Get the sum of the elements in this collectable as int.
      • sumLong

        long sumLong​(java.util.function.ToLongFunction<? super T> function)
        Get the sum of the elements in this collectable as long.
      • sumDouble

        double sumDouble​(java.util.function.ToDoubleFunction<? super T> function)
        Get the sum of the elements in this collectable as double.
      • avg

        java.util.Optional<T> avg()
        Get the average of the elements in this collectable.
      • avg

        <U> java.util.Optional<U> avg​(java.util.function.Function<? super T,​? extends U> function)
        Get the average of the elements in this collectable.
      • avgInt

        double avgInt​(java.util.function.ToIntFunction<? super T> function)
        Get the average of the elements in this collectable as int.
      • avgLong

        double avgLong​(java.util.function.ToLongFunction<? super T> function)
        Get the average of the elements in this collectable as long.
      • avgDouble

        double avgDouble​(java.util.function.ToDoubleFunction<? super T> function)
        Get the average of the elements in this collectable as double.
      • min

        java.util.Optional<T> min()
        Get the minimum value.

        This makes the unsafe assumption that <T extends Comparable<? super T>>

      • min

        java.util.Optional<T> min​(java.util.Comparator<? super T> comparator)
        Get the minimum value by a function.
      • min

        <U extends java.lang.Comparable<? super U>> java.util.Optional<U> min​(java.util.function.Function<? super T,​? extends U> function)
        Get the minimum value by a function.
      • min

        <U> java.util.Optional<U> min​(java.util.function.Function<? super T,​? extends U> function,
                                      java.util.Comparator<? super U> comparator)
        Get the minimum value by a function.
      • minBy

        <U extends java.lang.Comparable<? super U>> java.util.Optional<T> minBy​(java.util.function.Function<? super T,​? extends U> function)
        Get the minimum value by a function.
      • minBy

        <U> java.util.Optional<T> minBy​(java.util.function.Function<? super T,​? extends U> function,
                                        java.util.Comparator<? super U> comparator)
        Get the minimum value by a function.
      • minAll

        Seq<T> minAll()
        Get the minimum values.

        This makes the unsafe assumption that <T extends Comparable<? super T>>

      • minAll

        Seq<T> minAll​(java.util.Comparator<? super T> comparator)
        Get the minimum values by a function.
      • minAll

        <U extends java.lang.Comparable<? super U>> Seq<U> minAll​(java.util.function.Function<? super T,​? extends U> function)
        Get the minimum values by a function.
      • minAll

        <U> Seq<U> minAll​(java.util.function.Function<? super T,​? extends U> function,
                          java.util.Comparator<? super U> comparator)
        Get the minimum values by a function.
      • minAllBy

        <U extends java.lang.Comparable<? super U>> Seq<T> minAllBy​(java.util.function.Function<? super T,​? extends U> function)
        Get the minimum values by a function.
      • minAllBy

        <U> Seq<T> minAllBy​(java.util.function.Function<? super T,​? extends U> function,
                            java.util.Comparator<? super U> comparator)
        Get the minimum values by a function.
      • max

        java.util.Optional<T> max()
        Get the maximum value.

        This makes the unsafe assumption that <T extends Comparable<? super T>>

      • max

        java.util.Optional<T> max​(java.util.Comparator<? super T> comparator)
        Get the maximum value by a function.
      • max

        <U extends java.lang.Comparable<? super U>> java.util.Optional<U> max​(java.util.function.Function<? super T,​? extends U> function)
        Get the maximum value by a function.
      • max

        <U> java.util.Optional<U> max​(java.util.function.Function<? super T,​? extends U> function,
                                      java.util.Comparator<? super U> comparator)
        Get the maximum value by a function.
      • maxBy

        <U extends java.lang.Comparable<? super U>> java.util.Optional<T> maxBy​(java.util.function.Function<? super T,​? extends U> function)
        Get the maximum value by a function.
      • maxBy

        <U> java.util.Optional<T> maxBy​(java.util.function.Function<? super T,​? extends U> function,
                                        java.util.Comparator<? super U> comparator)
        Get the maximum value by a function.
      • maxAll

        Seq<T> maxAll()
        Get the maximum values.

        This makes the unsafe assumption that <T extends Comparable<? super T>>

      • maxAll

        Seq<T> maxAll​(java.util.Comparator<? super T> comparator)
        Get the maximum values by a function.
      • maxAll

        <U extends java.lang.Comparable<? super U>> Seq<U> maxAll​(java.util.function.Function<? super T,​? extends U> function)
        Get the maximum values by a function.
      • maxAll

        <U> Seq<U> maxAll​(java.util.function.Function<? super T,​? extends U> function,
                          java.util.Comparator<? super U> comparator)
        Get the maximum values by a function.
      • maxAllBy

        <U extends java.lang.Comparable<? super U>> Seq<T> maxAllBy​(java.util.function.Function<? super T,​? extends U> function)
        Get the maximum values by a function.
      • maxAllBy

        <U> Seq<T> maxAllBy​(java.util.function.Function<? super T,​? extends U> function,
                            java.util.Comparator<? super U> comparator)
        Get the maximum values by a function.
      • median

        java.util.Optional<T> median()
        Get the median value.

        This makes the unsafe assumption that <T extends Comparable<? super T>>

      • median

        java.util.Optional<T> median​(java.util.Comparator<? super T> comparator)
        Get the median value.
      • medianBy

        <U extends java.lang.Comparable<? super U>> java.util.Optional<T> medianBy​(java.util.function.Function<? super T,​? extends U> function)
        Get the median value by a function.
      • medianBy

        <U> java.util.Optional<T> medianBy​(java.util.function.Function<? super T,​? extends U> function,
                                           java.util.Comparator<? super U> comparator)
        Get the median value by a function.
      • percentile

        java.util.Optional<T> percentile​(double percentile)
        Get the discrete percentile value.

        This makes the unsafe assumption that <T extends Comparable<? super T>>

      • percentile

        java.util.Optional<T> percentile​(double percentile,
                                         java.util.Comparator<? super T> comparator)
        Get the discrete percentile value.
      • percentileBy

        <U extends java.lang.Comparable<? super U>> java.util.Optional<T> percentileBy​(double percentile,
                                                                                       java.util.function.Function<? super T,​? extends U> function)
        Get the discrete percentile value by a function.
      • percentileBy

        <U> java.util.Optional<T> percentileBy​(double percentile,
                                               java.util.function.Function<? super T,​? extends U> function,
                                               java.util.Comparator<? super U> comparator)
        Get the discrete percentile value by a function.
      • allMatch

        boolean allMatch​(java.util.function.Predicate<? super T> predicate)
        Whether all elements in the collectable match a given predicate.
      • anyMatch

        boolean anyMatch​(java.util.function.Predicate<? super T> predicate)
        Whether any element in the collectable matches a given predicate.
      • noneMatch

        boolean noneMatch​(java.util.function.Predicate<? super T> predicate)
        Whether no element in the collectable matches a given predicate.
      • bitAnd

        java.util.Optional<T> bitAnd()
        Collect all bits in this stream into a single value by applying bitwise and.
      • bitAnd

        <U> java.util.Optional<U> bitAnd​(java.util.function.Function<? super T,​? extends U> function)
        Collect all bits in this stream into a single value by applying bitwise and.
      • bitAndInt

        int bitAndInt​(java.util.function.ToIntFunction<? super T> function)
        Collect all bits in this stream into a single value by applying bitwise and.
      • bitAndLong

        long bitAndLong​(java.util.function.ToLongFunction<? super T> function)
        Collect all bits in this stream into a single value by applying bitwise and.
      • bitOr

        java.util.Optional<T> bitOr()
        Collect all bits in this stream into a single value by applying bitwise or.
      • bitOr

        <U> java.util.Optional<U> bitOr​(java.util.function.Function<? super T,​? extends U> function)
        Collect all bits in this stream into a single value by applying bitwise or.
      • bitOrInt

        int bitOrInt​(java.util.function.ToIntFunction<? super T> function)
        Collect all bits in this stream into a single value by applying bitwise or.
      • bitOrLong

        long bitOrLong​(java.util.function.ToLongFunction<? super T> function)
        Collect all bits in this stream into a single value by applying bitwise or.
      • toList

        java.util.List<T> toList()
        Collect the collectable into an ArrayList.
      • toList

        <L extends java.util.List<T>> L toList​(java.util.function.Supplier<L> factory)
        Collect the collectable into a List.
      • toUnmodifiableList

        java.util.List<T> toUnmodifiableList()
        Collect the collectable into an unmodifiable List.
      • toSet

        java.util.Set<T> toSet()
        Collect the collectable into a LinkedHashSet.
      • toSet

        <S extends java.util.Set<T>> S toSet​(java.util.function.Supplier<S> factory)
        Collect the collectable into a Set.
      • toUnmodifiableSet

        java.util.Set<T> toUnmodifiableSet()
        Collect the collectable into an unmodifiable Set.
      • toCollection

        <C extends java.util.Collection<T>> C toCollection​(java.util.function.Supplier<C> factory)
        Collect the collectable into a Collection.
      • toMap

        <K,​V> java.util.Map<K,​V> toMap​(java.util.function.Function<? super T,​? extends K> keyMapper,
                                                   java.util.function.Function<? super T,​? extends V> valueMapper)
        Collect the collectable into a Map.
      • toMap

        <K> java.util.Map<K,​T> toMap​(java.util.function.Function<? super T,​? extends K> keyMapper)
        Collect the collectable into a Map with the given keys and the self element as value.
      • toString

        java.lang.String toString​(java.lang.CharSequence delimiter)
        Consume a stream and concatenate all elements using a separator.
      • toString

        java.lang.String toString​(java.lang.CharSequence delimiter,
                                  java.lang.CharSequence prefix,
                                  java.lang.CharSequence suffix)
        Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence, CharSequence, CharSequence) collector.
      • commonPrefix

        java.lang.String commonPrefix()
        Get the common prefix of all strings (or to-stringed values) in this stream.
      • commonSuffix

        java.lang.String commonSuffix()
        Get the common prefix of all strings (or to-stringed values) in this stream.