Method Detail

• tuple

  static Tuple0 tuple()

  Construct a tuple of degree 0.

• tuple

  static <T1> Tuple1<T1> tuple(T1 v1)

  Construct a tuple of degree 1.

• tuple

  static <T1,T2> Tuple2<T1,T2> tuple(T1 v1,
                                     T2 v2)

  Construct a tuple of degree 2.

• tuple

  static <T1,T2,T3> Tuple3<T1,T2,T3> tuple(T1 v1,
                                           T2 v2,
                                           T3 v3)

  Construct a tuple of degree 3.

• tuple

  static <T1,T2,T3,T4> Tuple4<T1,T2,T3,T4> tuple(T1 v1,
                                                 T2 v2,
                                                 T3 v3,
                                                 T4 v4)

  Construct a tuple of degree 4.

• tuple

  static <T1,T2,T3,T4,T5> Tuple5<T1,T2,T3,T4,T5> tuple(T1 v1,
                                                       T2 v2,
                                                       T3 v3,
                                                       T4 v4,
                                                       T5 v5)

  Construct a tuple of degree 5.

• tuple

  static <T1,T2,T3,T4,T5,T6> Tuple6<T1,T2,T3,T4,T5,T6> tuple(T1 v1,
                                                             T2 v2,
                                                             T3 v3,
                                                             T4 v4,
                                                             T5 v5,
                                                             T6 v6)

  Construct a tuple of degree 6.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7> Tuple7<T1,T2,T3,T4,T5,T6,T7> tuple(T1 v1,
                                                                   T2 v2,
                                                                   T3 v3,
                                                                   T4 v4,
                                                                   T5 v5,
                                                                   T6 v6,
                                                                   T7 v7)

  Construct a tuple of degree 7.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<T1,T2,T3,T4,T5,T6,T7,T8> tuple(T1 v1,
                                                                         T2 v2,
                                                                         T3 v3,
                                                                         T4 v4,
                                                                         T5 v5,
                                                                         T6 v6,
                                                                         T7 v7,
                                                                         T8 v8)

  Construct a tuple of degree 8.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9> tuple(T1 v1,
                                                                               T2 v2,
                                                                               T3 v3,
                                                                               T4 v4,
                                                                               T5 v5,
                                                                               T6 v6,
                                                                               T7 v7,
                                                                               T8 v8,
                                                                               T9 v9)

  Construct a tuple of degree 9.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> tuple(T1 v1,
                                                                                        T2 v2,
                                                                                        T3 v3,
                                                                                        T4 v4,
                                                                                        T5 v5,
                                                                                        T6 v6,
                                                                                        T7 v7,
                                                                                        T8 v8,
                                                                                        T9 v9,
                                                                                        T10 v10)

  Construct a tuple of degree 10.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> tuple(T1 v1,
                                                                                                T2 v2,
                                                                                                T3 v3,
                                                                                                T4 v4,
                                                                                                T5 v5,
                                                                                                T6 v6,
                                                                                                T7 v7,
                                                                                                T8 v8,
                                                                                                T9 v9,
                                                                                                T10 v10,
                                                                                                T11 v11)

  Construct a tuple of degree 11.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> tuple(T1 v1,
                                                                                                        T2 v2,
                                                                                                        T3 v3,
                                                                                                        T4 v4,
                                                                                                        T5 v5,
                                                                                                        T6 v6,
                                                                                                        T7 v7,
                                                                                                        T8 v8,
                                                                                                        T9 v9,
                                                                                                        T10 v10,
                                                                                                        T11 v11,
                                                                                                        T12 v12)

  Construct a tuple of degree 12.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> tuple(T1 v1,
                                                                                                                T2 v2,
                                                                                                                T3 v3,
                                                                                                                T4 v4,
                                                                                                                T5 v5,
                                                                                                                T6 v6,
                                                                                                                T7 v7,
                                                                                                                T8 v8,
                                                                                                                T9 v9,
                                                                                                                T10 v10,
                                                                                                                T11 v11,
                                                                                                                T12 v12,
                                                                                                                T13 v13)

  Construct a tuple of degree 13.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> tuple(T1 v1,
                                                                                                                        T2 v2,
                                                                                                                        T3 v3,
                                                                                                                        T4 v4,
                                                                                                                        T5 v5,
                                                                                                                        T6 v6,
                                                                                                                        T7 v7,
                                                                                                                        T8 v8,
                                                                                                                        T9 v9,
                                                                                                                        T10 v10,
                                                                                                                        T11 v11,
                                                                                                                        T12 v12,
                                                                                                                        T13 v13,
                                                                                                                        T14 v14)

  Construct a tuple of degree 14.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> tuple(T1 v1,
                                                                                                                                T2 v2,
                                                                                                                                T3 v3,
                                                                                                                                T4 v4,
                                                                                                                                T5 v5,
                                                                                                                                T6 v6,
                                                                                                                                T7 v7,
                                                                                                                                T8 v8,
                                                                                                                                T9 v9,
                                                                                                                                T10 v10,
                                                                                                                                T11 v11,
                                                                                                                                T12 v12,
                                                                                                                                T13 v13,
                                                                                                                                T14 v14,
                                                                                                                                T15 v15)

  Construct a tuple of degree 15.

• tuple

  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> tuple(T1 v1,
                                                                                                                                        T2 v2,
                                                                                                                                        T3 v3,
                                                                                                                                        T4 v4,
                                                                                                                                        T5 v5,
                                                                                                                                        T6 v6,
                                                                                                                                        T7 v7,
                                                                                                                                        T8 v8,
                                                                                                                                        T9 v9,
                                                                                                                                        T10 v10,
                                                                                                                                        T11 v11,
                                                                                                                                        T12 v12,
                                                                                                                                        T13 v13,
                                                                                                                                        T14 v14,
                                                                                                                                        T15 v15,
                                                                                                                                        T16 v16)

  Construct a tuple of degree 16.

• collectors

  static <T,A1,D1> Collector<T,Tuple1<A1>,Tuple1<D1>> collectors(Collector<? super T,A1,D1> collector1)

  Construct a tuple collector of degree 1.

• collectors

  static <T,A1,A2,D1,D2> Collector<T,Tuple2<A1,A2>,Tuple2<D1,D2>> collectors(Collector<? super T,A1,D1> collector1,
                                                                             Collector<? super T,A2,D2> collector2)

  Construct a tuple collector of degree 2.

• collectors

  static <T,A1,A2,A3,D1,D2,D3> Collector<T,Tuple3<A1,A2,A3>,Tuple3<D1,D2,D3>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                         Collector<? super T,A2,D2> collector2,
                                                                                         Collector<? super T,A3,D3> collector3)

  Construct a tuple collector of degree 3.

• collectors

  static <T,A1,A2,A3,A4,D1,D2,D3,D4> Collector<T,Tuple4<A1,A2,A3,A4>,Tuple4<D1,D2,D3,D4>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                     Collector<? super T,A2,D2> collector2,
                                                                                                     Collector<? super T,A3,D3> collector3,
                                                                                                     Collector<? super T,A4,D4> collector4)

  Construct a tuple collector of degree 4.

• collectors

  static <T,A1,A2,A3,A4,A5,D1,D2,D3,D4,D5> Collector<T,Tuple5<A1,A2,A3,A4,A5>,Tuple5<D1,D2,D3,D4,D5>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                 Collector<? super T,A2,D2> collector2,
                                                                                                                 Collector<? super T,A3,D3> collector3,
                                                                                                                 Collector<? super T,A4,D4> collector4,
                                                                                                                 Collector<? super T,A5,D5> collector5)

  Construct a tuple collector of degree 5.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,D1,D2,D3,D4,D5,D6> Collector<T,Tuple6<A1,A2,A3,A4,A5,A6>,Tuple6<D1,D2,D3,D4,D5,D6>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                             Collector<? super T,A2,D2> collector2,
                                                                                                                             Collector<? super T,A3,D3> collector3,
                                                                                                                             Collector<? super T,A4,D4> collector4,
                                                                                                                             Collector<? super T,A5,D5> collector5,
                                                                                                                             Collector<? super T,A6,D6> collector6)

  Construct a tuple collector of degree 6.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,D1,D2,D3,D4,D5,D6,D7> Collector<T,Tuple7<A1,A2,A3,A4,A5,A6,A7>,Tuple7<D1,D2,D3,D4,D5,D6,D7>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                         Collector<? super T,A2,D2> collector2,
                                                                                                                                         Collector<? super T,A3,D3> collector3,
                                                                                                                                         Collector<? super T,A4,D4> collector4,
                                                                                                                                         Collector<? super T,A5,D5> collector5,
                                                                                                                                         Collector<? super T,A6,D6> collector6,
                                                                                                                                         Collector<? super T,A7,D7> collector7)

  Construct a tuple collector of degree 7.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,D1,D2,D3,D4,D5,D6,D7,D8> Collector<T,Tuple8<A1,A2,A3,A4,A5,A6,A7,A8>,Tuple8<D1,D2,D3,D4,D5,D6,D7,D8>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                     Collector<? super T,A2,D2> collector2,
                                                                                                                                                     Collector<? super T,A3,D3> collector3,
                                                                                                                                                     Collector<? super T,A4,D4> collector4,
                                                                                                                                                     Collector<? super T,A5,D5> collector5,
                                                                                                                                                     Collector<? super T,A6,D6> collector6,
                                                                                                                                                     Collector<? super T,A7,D7> collector7,
                                                                                                                                                     Collector<? super T,A8,D8> collector8)

  Construct a tuple collector of degree 8.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,D1,D2,D3,D4,D5,D6,D7,D8,D9> Collector<T,Tuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9>,Tuple9<D1,D2,D3,D4,D5,D6,D7,D8,D9>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                                 Collector<? super T,A2,D2> collector2,
                                                                                                                                                                 Collector<? super T,A3,D3> collector3,
                                                                                                                                                                 Collector<? super T,A4,D4> collector4,
                                                                                                                                                                 Collector<? super T,A5,D5> collector5,
                                                                                                                                                                 Collector<? super T,A6,D6> collector6,
                                                                                                                                                                 Collector<? super T,A7,D7> collector7,
                                                                                                                                                                 Collector<? super T,A8,D8> collector8,
                                                                                                                                                                 Collector<? super T,A9,D9> collector9)

  Construct a tuple collector of degree 9.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10> Collector<T,Tuple10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10>,Tuple10<D1,D2,D3,D4,D5,D6,D7,D8,D9,D10>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                   Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                   Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                   Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                   Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                   Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                   Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                   Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                   Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                   Collector<? super T,A10,D10> collector10)

  Construct a tuple collector of degree 10.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11> Collector<T,Tuple11<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11>,Tuple11<D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                   Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                   Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                   Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                   Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                   Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                   Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                   Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                   Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                   Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                   Collector<? super T,A11,D11> collector11)

  Construct a tuple collector of degree 11.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12> Collector<T,Tuple12<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12>,Tuple12<D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                   Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                   Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                   Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                   Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                   Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                   Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                   Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                   Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                   Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                   Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                   Collector<? super T,A12,D12> collector12)

  Construct a tuple collector of degree 12.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13> Collector<T,Tuple13<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13>,Tuple13<D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                   Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                   Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                   Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                   Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                   Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                   Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                   Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                   Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                   Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                   Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                   Collector<? super T,A12,D12> collector12,
                                                                                                                                                                                                                                   Collector<? super T,A13,D13> collector13)

  Construct a tuple collector of degree 13.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13,D14> Collector<T,Tuple14<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14>,Tuple14<D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13,D14>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                                   Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                                   Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                                   Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                                   Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                                   Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                                   Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                                   Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                                   Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                                   Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                                   Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                                   Collector<? super T,A12,D12> collector12,
                                                                                                                                                                                                                                                   Collector<? super T,A13,D13> collector13,
                                                                                                                                                                                                                                                   Collector<? super T,A14,D14> collector14)

  Construct a tuple collector of degree 14.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13,D14,D15> Collector<T,Tuple15<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15>,Tuple15<D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13,D14,D15>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                                                   Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                                                   Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                                                   Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                                                   Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                                                   Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                                                   Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                                                   Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                                                   Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                                                   Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                                                   Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                                                   Collector<? super T,A12,D12> collector12,
                                                                                                                                                                                                                                                                   Collector<? super T,A13,D13> collector13,
                                                                                                                                                                                                                                                                   Collector<? super T,A14,D14> collector14,
                                                                                                                                                                                                                                                                   Collector<? super T,A15,D15> collector15)

  Construct a tuple collector of degree 15.

• collectors

  static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13,D14,D15,D16> Collector<T,Tuple16<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16>,Tuple16<D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13,D14,D15,D16>> collectors(Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                                                                   Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                                                                   Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                                                                   Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                                                                   Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                                                                   Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                                                                   Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                                                                   Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                                                                   Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                                                                   Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                                                                   Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                                                                   Collector<? super T,A12,D12> collector12,
                                                                                                                                                                                                                                                                                   Collector<? super T,A13,D13> collector13,
                                                                                                                                                                                                                                                                                   Collector<? super T,A14,D14> collector14,
                                                                                                                                                                                                                                                                                   Collector<? super T,A15,D15> collector15,
                                                                                                                                                                                                                                                                                   Collector<? super T,A16,D16> collector16)

  Construct a tuple collector of degree 16.

• range

  static <T extends Comparable<T>> Range<T> range(T t1,
                                                  T t2)

  Create a new range.

• array

  Object[] array()

  Get an array representation of this tuple.

• list

  List<?> list()

  Get a list representation of this tuple.

• degree

  int degree()

  The degree of this tuple.