org.jooq.lambda.tuple

Interface Tuple

All Superinterfaces:

Iterable<Object>

All Known Implementing Classes:

Range, Tuple0, Tuple1, Tuple10, Tuple11, Tuple12, Tuple13, Tuple14, Tuple15, Tuple16, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, Tuple8, Tuple9

public interface Tuple
extends Iterable<Object>

A tuple.

Author:

Lukas Eder

Method Summary

Modifier and Type	Method and Description
Object[]	array() Get an array representation of this tuple.
static <T,A1,D1> java.util.stream.Collector<T,Tuple1<A1>,Tuple1<D1>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1) Construct a tuple collector of degree 1.
static <T,A1,A2,D1,D2> java.util.stream.Collector<T,Tuple2<A1,A2>,Tuple2<D1,D2>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2) Construct a tuple collector of degree 2.
static <T,A1,A2,A3,D1,D2,D3> java.util.stream.Collector<T,Tuple3<A1,A2,A3>,Tuple3<D1,D2,D3>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3) Construct a tuple collector of degree 3.
static <T,A1,A2,A3,A4,D1,D2,D3,D4> java.util.stream.Collector<T,Tuple4<A1,A2,A3,A4>,Tuple4<D1,D2,D3,D4>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4) Construct a tuple collector of degree 4.
static <T,A1,A2,A3,A4,A5,D1,D2,D3,D4,D5> java.util.stream.Collector<T,Tuple5<A1,A2,A3,A4,A5>,Tuple5<D1,D2,D3,D4,D5>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5) Construct a tuple collector of degree 5.
static <T,A1,A2,A3,A4,A5,A6,D1,D2,D3,D4,D5,D6> java.util.stream.Collector<T,Tuple6<A1,A2,A3,A4,A5,A6>,Tuple6<D1,D2,D3,D4,D5,D6>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6) Construct a tuple collector of degree 6.
static <T,A1,A2,A3,A4,A5,A6,A7,D1,D2,D3,D4,D5,D6,D7> java.util.stream.Collector<T,Tuple7<A1,A2,A3,A4,A5,A6,A7>,Tuple7<D1,D2,D3,D4,D5,D6,D7>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7) Construct a tuple collector of degree 7.
static <T,A1,A2,A3,A4,A5,A6,A7,A8,D1,D2,D3,D4,D5,D6,D7,D8> java.util.stream.Collector<T,Tuple8<A1,A2,A3,A4,A5,A6,A7,A8>,Tuple8<D1,D2,D3,D4,D5,D6,D7,D8>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8) Construct a tuple collector of degree 8.
static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,D1,D2,D3,D4,D5,D6,D7,D8,D9> java.util.stream.Collector<T,Tuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9>,Tuple9<D1,D2,D3,D4,D5,D6,D7,D8,D9>>	collectors(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8, java.util.stream.Collector<? super T,A9,D9> collector9) Construct a tuple collector of degree 9.
static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8, java.util.stream.Collector<? super T,A9,D9> collector9, java.util.stream.Collector<? super T,A10,D10> collector10) Construct a tuple collector of degree 10.
static <T,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,D1,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8, java.util.stream.Collector<? super T,A9,D9> collector9, java.util.stream.Collector<? super T,A10,D10> collector10, java.util.stream.Collector<? super T,A11,D11> collector11) Construct a tuple collector of degree 11.
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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8, java.util.stream.Collector<? super T,A9,D9> collector9, java.util.stream.Collector<? super T,A10,D10> collector10, java.util.stream.Collector<? super T,A11,D11> collector11, java.util.stream.Collector<? super T,A12,D12> collector12) Construct a tuple collector of degree 12.
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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8, java.util.stream.Collector<? super T,A9,D9> collector9, java.util.stream.Collector<? super T,A10,D10> collector10, java.util.stream.Collector<? super T,A11,D11> collector11, java.util.stream.Collector<? super T,A12,D12> collector12, java.util.stream.Collector<? super T,A13,D13> collector13) Construct a tuple collector of degree 13.
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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8, java.util.stream.Collector<? super T,A9,D9> collector9, java.util.stream.Collector<? super T,A10,D10> collector10, java.util.stream.Collector<? super T,A11,D11> collector11, java.util.stream.Collector<? super T,A12,D12> collector12, java.util.stream.Collector<? super T,A13,D13> collector13, java.util.stream.Collector<? super T,A14,D14> collector14) Construct a tuple collector of degree 14.
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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8, java.util.stream.Collector<? super T,A9,D9> collector9, java.util.stream.Collector<? super T,A10,D10> collector10, java.util.stream.Collector<? super T,A11,D11> collector11, java.util.stream.Collector<? super T,A12,D12> collector12, java.util.stream.Collector<? super T,A13,D13> collector13, java.util.stream.Collector<? super T,A14,D14> collector14, java.util.stream.Collector<? super T,A15,D15> collector15) Construct a tuple collector of degree 15.
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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1, java.util.stream.Collector<? super T,A2,D2> collector2, java.util.stream.Collector<? super T,A3,D3> collector3, java.util.stream.Collector<? super T,A4,D4> collector4, java.util.stream.Collector<? super T,A5,D5> collector5, java.util.stream.Collector<? super T,A6,D6> collector6, java.util.stream.Collector<? super T,A7,D7> collector7, java.util.stream.Collector<? super T,A8,D8> collector8, java.util.stream.Collector<? super T,A9,D9> collector9, java.util.stream.Collector<? super T,A10,D10> collector10, java.util.stream.Collector<? super T,A11,D11> collector11, java.util.stream.Collector<? super T,A12,D12> collector12, java.util.stream.Collector<? super T,A13,D13> collector13, java.util.stream.Collector<? super T,A14,D14> collector14, java.util.stream.Collector<? super T,A15,D15> collector15, java.util.stream.Collector<? super T,A16,D16> collector16) Construct a tuple collector of degree 16.
int	degree() The degree of this tuple.
List<?>	list() Get a list representation of this tuple.
static <T extends Comparable<T>> Range<T>	range(T t1, T t2) Create a new range.
static Tuple0	tuple() Construct a tuple of degree 0.
static <T1> Tuple1<T1>	tuple(T1 v1) Construct a tuple of degree 1.
static <T1,T2> Tuple2<T1,T2>	tuple(T1 v1, T2 v2) Construct a tuple of degree 2.
static <T1,T2,T3> Tuple3<T1,T2,T3>	tuple(T1 v1, T2 v2, T3 v3) Construct a tuple of degree 3.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.

Methods inherited from interface java.lang.Iterable

forEach, iterator, spliterator

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> java.util.stream.Collector<T,Tuple1<A1>,Tuple1<D1>> collectors(java.util.stream.Collector<? super T,A1,D1> collector1)

Construct a tuple collector of degree 1.

collectors

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

Construct a tuple collector of degree 2.

collectors

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

Construct a tuple collector of degree 3.

collectors

static <T,A1,A2,A3,A4,D1,D2,D3,D4> java.util.stream.Collector<T,Tuple4<A1,A2,A3,A4>,Tuple4<D1,D2,D3,D4>> collectors(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                    java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                    java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                    java.util.stream.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> java.util.stream.Collector<T,Tuple5<A1,A2,A3,A4,A5>,Tuple5<D1,D2,D3,D4,D5>> collectors(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                java.util.stream.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> java.util.stream.Collector<T,Tuple6<A1,A2,A3,A4,A5,A6>,Tuple6<D1,D2,D3,D4,D5,D6>> collectors(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                            java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                            java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                            java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                            java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                            java.util.stream.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> java.util.stream.Collector<T,Tuple7<A1,A2,A3,A4,A5,A6,A7>,Tuple7<D1,D2,D3,D4,D5,D6,D7>> collectors(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                        java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                        java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                        java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                        java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                        java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                        java.util.stream.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> java.util.stream.Collector<T,Tuple8<A1,A2,A3,A4,A5,A6,A7,A8>,Tuple8<D1,D2,D3,D4,D5,D6,D7,D8>> collectors(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                    java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                    java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                    java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                    java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                    java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                    java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                    java.util.stream.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> java.util.stream.Collector<T,Tuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9>,Tuple9<D1,D2,D3,D4,D5,D6,D7,D8,D9>> collectors(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                java.util.stream.Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                java.util.stream.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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                  java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                  java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                  java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                  java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                  java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                  java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                  java.util.stream.Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                  java.util.stream.Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                  java.util.stream.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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                  java.util.stream.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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                  java.util.stream.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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A12,D12> collector12,
                                                                                                                                                                                                                                                  java.util.stream.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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A12,D12> collector12,
                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A13,D13> collector13,
                                                                                                                                                                                                                                                                  java.util.stream.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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A12,D12> collector12,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A13,D13> collector13,
                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A14,D14> collector14,
                                                                                                                                                                                                                                                                                  java.util.stream.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> java.util.stream.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(java.util.stream.Collector<? super T,A1,D1> collector1,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A2,D2> collector2,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A3,D3> collector3,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A4,D4> collector4,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A5,D5> collector5,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A6,D6> collector6,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A7,D7> collector7,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A8,D8> collector8,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A9,D9> collector9,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A10,D10> collector10,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A11,D11> collector11,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A12,D12> collector12,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A13,D13> collector13,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A14,D14> collector14,
                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,A15,D15> collector15,
                                                                                                                                                                                                                                                                                                  java.util.stream.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.