NTuple4 (CAFF Viewer Class Documentation)

java.lang.Object
- de.caff.generics.tuple.ITuple4.Base<T1,T2,T3,T4>
- - de.caff.generics.tuple.NTuple4<T1,T2,T3,T4>

Type Parameters:

T1 - type of first element

T2 - type of second element

T3 - type of third element

T4 - type of fourth element

All Implemented Interfaces:

ITuple4<T1,T2,T3,T4>, java.io.Serializable
```
public class NTuple4<T1,T2,T3,T4>
extends ITuple4.Base<T1,T2,T3,T4>
implements java.io.Serializable
```
Immutable tuple with 4 nullable elements. If you want to iterate over a tuple or access its elements by index (note that both is only possible for a common super type of the tuple's types) Indexable.viewTuple(ITuple4) will come to help. Note that this class is automatically created by tools.TupleClassCreator (not yet public).

Since:

November 17, 2021

Author:

Rammi

See Also:

Tuple4, Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface de.caff.generics.tuple.ITuple4
  ITuple4.Base<T1,T2,T3,T4>

Constructor Summary

Constructors
Constructor and Description

NTuple4(T1 e1, T2 e2, T3 e3, T4 e4)
Constructor.

Constructors
Constructor and Description
`NTuple4(T1 e1, T2 e2, T3 e3, T4 e4)` Constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`T1`	`_1()` Get the first element.
`NTuple2<T1,T2>`	`_12()` Create a new 2-tuple from this one where the elements are ordered: 1st, 2nd.
`NTuple3<T1,T2,T3>`	`_123()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
`NTuple3<T1,T2,T4>`	`_124()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
`NTuple4<T1,T2,T4,T3>`	`_1243()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 3rd.
`NTuple2<T1,T3>`	`_13()` Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
`NTuple3<T1,T3,T2>`	`_132()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
`NTuple4<T1,T3,T2,T4>`	`_1324()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 4th.
`NTuple3<T1,T3,T4>`	`_134()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
`NTuple4<T1,T3,T4,T2>`	`_1342()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 2nd.
`NTuple2<T1,T4>`	`_14()` Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
`NTuple3<T1,T4,T2>`	`_142()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
`NTuple4<T1,T4,T2,T3>`	`_1423()` Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 3rd.
`NTuple3<T1,T4,T3>`	`_143()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
`NTuple4<T1,T4,T3,T2>`	`_1432()` Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 3rd, 2nd.
`T2`	`_2()` Get the second element.
`NTuple2<T2,T1>`	`_21()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
`NTuple3<T2,T1,T3>`	`_213()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
`NTuple4<T2,T1,T3,T4>`	`_2134()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th.
`NTuple3<T2,T1,T4>`	`_214()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
`NTuple4<T2,T1,T4,T3>`	`_2143()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 3rd.
`NTuple2<T2,T3>`	`_23()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
`NTuple3<T2,T3,T1>`	`_231()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
`NTuple4<T2,T3,T1,T4>`	`_2314()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 4th.
`NTuple3<T2,T3,T4>`	`_234()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
`NTuple4<T2,T3,T4,T1>`	`_2341()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 1st.
`NTuple2<T2,T4>`	`_24()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
`NTuple3<T2,T4,T1>`	`_241()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
`NTuple4<T2,T4,T1,T3>`	`_2413()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 3rd.
`NTuple3<T2,T4,T3>`	`_243()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
`NTuple4<T2,T4,T3,T1>`	`_2431()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 3rd, 1st.
`T3`	`_3()` Get the third element.
`NTuple2<T3,T1>`	`_31()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
`NTuple3<T3,T1,T2>`	`_312()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
`NTuple4<T3,T1,T2,T4>`	`_3124()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 4th.
`NTuple3<T3,T1,T4>`	`_314()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
`NTuple4<T3,T1,T4,T2>`	`_3142()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 2nd.
`NTuple2<T3,T2>`	`_32()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
`NTuple3<T3,T2,T1>`	`_321()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
`NTuple4<T3,T2,T1,T4>`	`_3214()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 4th.
`NTuple3<T3,T2,T4>`	`_324()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
`NTuple4<T3,T2,T4,T1>`	`_3241()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 1st.
`NTuple2<T3,T4>`	`_34()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
`NTuple3<T3,T4,T1>`	`_341()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
`NTuple4<T3,T4,T1,T2>`	`_3412()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 2nd.
`NTuple3<T3,T4,T2>`	`_342()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
`NTuple4<T3,T4,T2,T1>`	`_3421()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 1st.
`T4`	`_4()` Get the fourth element.
`NTuple2<T4,T1>`	`_41()` Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
`NTuple3<T4,T1,T2>`	`_412()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
`NTuple4<T4,T1,T2,T3>`	`_4123()` Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 3rd.
`NTuple3<T4,T1,T3>`	`_413()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
`NTuple4<T4,T1,T3,T2>`	`_4132()` Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 2nd.
`NTuple2<T4,T2>`	`_42()` Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
`NTuple3<T4,T2,T1>`	`_421()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
`NTuple4<T4,T2,T1,T3>`	`_4213()` Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 3rd.
`NTuple3<T4,T2,T3>`	`_423()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
`NTuple4<T4,T2,T3,T1>`	`_4231()` Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 1st.
`NTuple2<T4,T3>`	`_43()` Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
`NTuple3<T4,T3,T1>`	`_431()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
`NTuple4<T4,T3,T1,T2>`	`_4312()` Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 2nd.
`NTuple3<T4,T3,T2>`	`_432()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
`NTuple4<T4,T3,T2,T1>`	`_4321()` Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 1st.
`NTuple4<T1,T2,T3,T4>`	`frozen()` Convert this into an object of a concrete tuple implementation.
`<T> NTuple5<T,T1,T2,T3,T4>`	`i1(T e1)` Create a 5-tuple from this 4-tuple by inserting a new first element.
`<T> NTuple5<T1,T,T2,T3,T4>`	`i2(T e2)` Create a 5-tuple from this 4-tuple by inserting a new second element.
`<T> NTuple5<T1,T2,T,T3,T4>`	`i3(T e3)` Create a 5-tuple from this 4-tuple by inserting a new third element.
`<T> NTuple5<T1,T2,T3,T,T4>`	`i4(T e4)` Create a 5-tuple from this 4-tuple by inserting a new fourth element.
`<T> NTuple5<T1,T2,T3,T4,T>`	`i5(T e5)` Create a 5-tuple from this 4-tuple by adding a new fifth element.
`java.lang.String`	`toString()`
`<E1> NTuple4<E1,T2,T3,T4>`	`x1(E1 e1)` Create a 4-tuple from this one where the first element is exchanged.
`<E1,E2> NTuple4<E1,E2,T3,T4>`	`x12(E1 e1, E2 e2)` Create a 4-tuple from this one where the first and second elements are exchanged.
`<E1,E2,E3> NTuple4<E1,E2,E3,T4>`	`x123(E1 e1, E2 e2, E3 e3)` Create a 4-tuple from this one where the first, second, and thirdelements are exchanged.
`<E1,E2,E4> NTuple4<E1,E2,T3,E4>`	`x124(E1 e1, E2 e2, E4 e4)` Create a 4-tuple from this one where the first, second, and fourthelements are exchanged.
`<E1,E3> NTuple4<E1,T2,E3,T4>`	`x13(E1 e1, E3 e3)` Create a 4-tuple from this one where the first and third elements are exchanged.
`<E1,E3,E4> NTuple4<E1,T2,E3,E4>`	`x134(E1 e1, E3 e3, E4 e4)` Create a 4-tuple from this one where the first, third, and fourthelements are exchanged.
`<E1,E4> NTuple4<E1,T2,T3,E4>`	`x14(E1 e1, E4 e4)` Create a 4-tuple from this one where the first and fourth elements are exchanged.
`<E2> NTuple4<T1,E2,T3,T4>`	`x2(E2 e2)` Create a 4-tuple from this one where the second element is exchanged.
`<E2,E3> NTuple4<T1,E2,E3,T4>`	`x23(E2 e2, E3 e3)` Create a 4-tuple from this one where the second and third elements are exchanged.
`<E2,E3,E4> NTuple4<T1,E2,E3,E4>`	`x234(E2 e2, E3 e3, E4 e4)` Create a 4-tuple from this one where the second, third, and fourthelements are exchanged.
`<E2,E4> NTuple4<T1,E2,T3,E4>`	`x24(E2 e2, E4 e4)` Create a 4-tuple from this one where the second and fourth elements are exchanged.
`<E3> NTuple4<T1,T2,E3,T4>`	`x3(E3 e3)` Create a 4-tuple from this one where the third element is exchanged.
`<E3,E4> NTuple4<T1,T2,E3,E4>`	`x34(E3 e3, E4 e4)` Create a 4-tuple from this one where the third and fourth elements are exchanged.
`<E4> NTuple4<T1,T2,T3,E4>`	`x4(E4 e4)` Create a 4-tuple from this one where the fourth element is exchanged.

Methods inherited from class de.caff.generics.tuple.ITuple4.Base
asBase, equals, hashCode

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface de.caff.generics.tuple.ITuple4
concat1, concat2, concat3, concat4, concat5, concat6, concat7, concat8, concatPred1, concatPred2, concatPred3, concatPred4, concatPred5, concatPred6, concatPred7, concatPred8, concatProc1, concatProc2, concatProc3, concatProc4, concatProc5, concatProc6, concatProc7, concatProc8, equals, frozenNotNull, hash, invoke, sendTo, testBy, toString, toString, view

- Constructor Detail
  - NTuple4
```
public NTuple4(@Nullable
               T1 e1,
               @Nullable
               T2 e2,
               @Nullable
               T3 e3,
               @Nullable
               T4 e4)
```
    Constructor.
    
    Parameters:
    
    e1 - first element
    
    e2 - second element
    
    e3 - third element
    
    e4 - fourth element
- Method Detail
  - _1
```
@Nullable
public T1 _1()
```
    Description copied from interface: ITuple4
    
    Get the first element.
    
    Specified by:
    
    _1 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    first element
  - _2
```
@Nullable
public T2 _2()
```
    Description copied from interface: ITuple4
    
    Get the second element.
    
    Specified by:
    
    _2 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    second element
  - _3
```
@Nullable
public T3 _3()
```
    Description copied from interface: ITuple4
    
    Get the third element.
    
    Specified by:
    
    _3 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    third element
  - _4
```
@Nullable
public T4 _4()
```
    Description copied from interface: ITuple4
    
    Get the fourth element.
    
    Specified by:
    
    _4 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    fourth element
  - _1243
```
@NotNull
public NTuple4<T1,T2,T4,T3> _1243()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 3rd.
    
    Specified by:
    
    _1243 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _1423
```
@NotNull
public NTuple4<T1,T4,T2,T3> _1423()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 3rd.
    
    Specified by:
    
    _1423 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _4123
```
@NotNull
public NTuple4<T4,T1,T2,T3> _4123()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 3rd.
    
    Specified by:
    
    _4123 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _4132
```
@NotNull
public NTuple4<T4,T1,T3,T2> _4132()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 2nd.
    
    Specified by:
    
    _4132 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _1432
```
@NotNull
public NTuple4<T1,T4,T3,T2> _1432()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 3rd, 2nd.
    
    Specified by:
    
    _1432 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _1342
```
@NotNull
public NTuple4<T1,T3,T4,T2> _1342()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 2nd.
    
    Specified by:
    
    _1342 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _1324
```
@NotNull
public NTuple4<T1,T3,T2,T4> _1324()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 4th.
    
    Specified by:
    
    _1324 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _3124
```
@NotNull
public NTuple4<T3,T1,T2,T4> _3124()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 4th.
    
    Specified by:
    
    _3124 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _3142
```
@NotNull
public NTuple4<T3,T1,T4,T2> _3142()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 2nd.
    
    Specified by:
    
    _3142 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _3412
```
@NotNull
public NTuple4<T3,T4,T1,T2> _3412()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 2nd.
    
    Specified by:
    
    _3412 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _4312
```
@NotNull
public NTuple4<T4,T3,T1,T2> _4312()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 2nd.
    
    Specified by:
    
    _4312 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _4321
```
@NotNull
public NTuple4<T4,T3,T2,T1> _4321()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 1st.
    
    Specified by:
    
    _4321 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _3421
```
@NotNull
public NTuple4<T3,T4,T2,T1> _3421()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 1st.
    
    Specified by:
    
    _3421 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _3241
```
@NotNull
public NTuple4<T3,T2,T4,T1> _3241()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 1st.
    
    Specified by:
    
    _3241 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _3214
```
@NotNull
public NTuple4<T3,T2,T1,T4> _3214()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 4th.
    
    Specified by:
    
    _3214 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _2314
```
@NotNull
public NTuple4<T2,T3,T1,T4> _2314()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 4th.
    
    Specified by:
    
    _2314 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _2341
```
@NotNull
public NTuple4<T2,T3,T4,T1> _2341()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 1st.
    
    Specified by:
    
    _2341 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _2431
```
@NotNull
public NTuple4<T2,T4,T3,T1> _2431()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 3rd, 1st.
    
    Specified by:
    
    _2431 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _4231
```
@NotNull
public NTuple4<T4,T2,T3,T1> _4231()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 1st.
    
    Specified by:
    
    _4231 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _4213
```
@NotNull
public NTuple4<T4,T2,T1,T3> _4213()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 3rd.
    
    Specified by:
    
    _4213 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _2413
```
@NotNull
public NTuple4<T2,T4,T1,T3> _2413()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 3rd.
    
    Specified by:
    
    _2413 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _2143
```
@NotNull
public NTuple4<T2,T1,T4,T3> _2143()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 3rd.
    
    Specified by:
    
    _2143 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _2134
```
@NotNull
public NTuple4<T2,T1,T3,T4> _2134()
```
    Description copied from interface: ITuple4
    
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th.
    
    Specified by:
    
    _2134 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _123
```
@NotNull
public NTuple3<T1,T2,T3> _123()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
    
    Specified by:
    
    _123 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _132
```
@NotNull
public NTuple3<T1,T3,T2> _132()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
    
    Specified by:
    
    _132 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _312
```
@NotNull
public NTuple3<T3,T1,T2> _312()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
    
    Specified by:
    
    _312 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _321
```
@NotNull
public NTuple3<T3,T2,T1> _321()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
    
    Specified by:
    
    _321 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _231
```
@NotNull
public NTuple3<T2,T3,T1> _231()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
    
    Specified by:
    
    _231 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _213
```
@NotNull
public NTuple3<T2,T1,T3> _213()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
    
    Specified by:
    
    _213 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _124
```
@NotNull
public NTuple3<T1,T2,T4> _124()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
    
    Specified by:
    
    _124 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _142
```
@NotNull
public NTuple3<T1,T4,T2> _142()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
    
    Specified by:
    
    _142 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _412
```
@NotNull
public NTuple3<T4,T1,T2> _412()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
    
    Specified by:
    
    _412 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _421
```
@NotNull
public NTuple3<T4,T2,T1> _421()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
    
    Specified by:
    
    _421 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _241
```
@NotNull
public NTuple3<T2,T4,T1> _241()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
    
    Specified by:
    
    _241 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _214
```
@NotNull
public NTuple3<T2,T1,T4> _214()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
    
    Specified by:
    
    _214 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _134
```
@NotNull
public NTuple3<T1,T3,T4> _134()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
    
    Specified by:
    
    _134 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _143
```
@NotNull
public NTuple3<T1,T4,T3> _143()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
    
    Specified by:
    
    _143 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _413
```
@NotNull
public NTuple3<T4,T1,T3> _413()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
    
    Specified by:
    
    _413 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _431
```
@NotNull
public NTuple3<T4,T3,T1> _431()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
    
    Specified by:
    
    _431 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _341
```
@NotNull
public NTuple3<T3,T4,T1> _341()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
    
    Specified by:
    
    _341 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _314
```
@NotNull
public NTuple3<T3,T1,T4> _314()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
    
    Specified by:
    
    _314 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _234
```
@NotNull
public NTuple3<T2,T3,T4> _234()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
    
    Specified by:
    
    _234 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _243
```
@NotNull
public NTuple3<T2,T4,T3> _243()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
    
    Specified by:
    
    _243 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _423
```
@NotNull
public NTuple3<T4,T2,T3> _423()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
    
    Specified by:
    
    _423 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _432
```
@NotNull
public NTuple3<T4,T3,T2> _432()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
    
    Specified by:
    
    _432 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _342
```
@NotNull
public NTuple3<T3,T4,T2> _342()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
    
    Specified by:
    
    _342 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _324
```
@NotNull
public NTuple3<T3,T2,T4> _324()
```
    Description copied from interface: ITuple4
    
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
    
    Specified by:
    
    _324 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _12
```
@NotNull
public NTuple2<T1,T2> _12()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 1st, 2nd.
    
    Specified by:
    
    _12 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _21
```
@NotNull
public NTuple2<T2,T1> _21()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
    
    Specified by:
    
    _21 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _13
```
@NotNull
public NTuple2<T1,T3> _13()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
    
    Specified by:
    
    _13 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _31
```
@NotNull
public NTuple2<T3,T1> _31()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
    
    Specified by:
    
    _31 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _23
```
@NotNull
public NTuple2<T2,T3> _23()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
    
    Specified by:
    
    _23 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _32
```
@NotNull
public NTuple2<T3,T2> _32()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
    
    Specified by:
    
    _32 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _14
```
@NotNull
public NTuple2<T1,T4> _14()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
    
    Specified by:
    
    _14 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _41
```
@NotNull
public NTuple2<T4,T1> _41()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
    
    Specified by:
    
    _41 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _24
```
@NotNull
public NTuple2<T2,T4> _24()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
    
    Specified by:
    
    _24 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _42
```
@NotNull
public NTuple2<T4,T2> _42()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
    
    Specified by:
    
    _42 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _34
```
@NotNull
public NTuple2<T3,T4> _34()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
    
    Specified by:
    
    _34 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - _43
```
@NotNull
public NTuple2<T4,T3> _43()
```
    Description copied from interface: ITuple4
    
    Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
    
    Specified by:
    
    _43 in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    reordered tuple
  - frozen
```
@NotNull
public NTuple4<T1,T2,T3,T4> frozen()
```
    Description copied from interface: ITuple4
    
    Convert this into an object of a concrete tuple implementation. This is useful because implementations may just be a view of something else. This method makes sure to decouple the tuple from the viewed object. The resulting tuple may contain null elements, see ITuple4.frozenNotNull() for a method which returns tuples which don't have nullable elements.
    
    Specified by:
    
    frozen in interface ITuple4<T1,T2,T3,T4>
    
    Returns:
    
    standalone tuple object
  - x1
```
@NotNull
public <E1> NTuple4<E1,T2,T3,T4> x1(@Nullable
                                             E1 e1)
```
    Create a 4-tuple from this one where the first element is exchanged.
    
    Type Parameters:
    
    E1 - type of exchanged first element
    
    Parameters:
    
    e1 - new first element
    
    Returns:
    
    tuple with exchanged element
  - x2
```
@NotNull
public <E2> NTuple4<T1,E2,T3,T4> x2(@Nullable
                                             E2 e2)
```
    Create a 4-tuple from this one where the second element is exchanged.
    
    Type Parameters:
    
    E2 - type of exchanged second element
    
    Parameters:
    
    e2 - new second element
    
    Returns:
    
    tuple with exchanged element
  - x3
```
@NotNull
public <E3> NTuple4<T1,T2,E3,T4> x3(@Nullable
                                             E3 e3)
```
    Create a 4-tuple from this one where the third element is exchanged.
    
    Type Parameters:
    
    E3 - type of exchanged third element
    
    Parameters:
    
    e3 - new third element
    
    Returns:
    
    tuple with exchanged element
  - x4
```
@NotNull
public <E4> NTuple4<T1,T2,T3,E4> x4(@Nullable
                                             E4 e4)
```
    Create a 4-tuple from this one where the fourth element is exchanged.
    
    Type Parameters:
    
    E4 - type of exchanged fourth element
    
    Parameters:
    
    e4 - new fourth element
    
    Returns:
    
    tuple with exchanged element
  - x12
```
@NotNull
public <E1,E2> NTuple4<E1,E2,T3,T4> x12(@Nullable
                                                 E1 e1,
                                                 @Nullable
                                                 E2 e2)
```
    Create a 4-tuple from this one where the first and second elements are exchanged.
    
    Type Parameters:
    
    E1 - type of exchanged first element
    
    E2 - type of exchanged second element
    
    Parameters:
    
    e1 - new first element
    
    e2 - new second element
    
    Returns:
    
    tuple with exchanged elements
  - x13
```
@NotNull
public <E1,E3> NTuple4<E1,T2,E3,T4> x13(@Nullable
                                                 E1 e1,
                                                 @Nullable
                                                 E3 e3)
```
    Create a 4-tuple from this one where the first and third elements are exchanged.
    
    Type Parameters:
    
    E1 - type of exchanged first element
    
    E3 - type of exchanged third element
    
    Parameters:
    
    e1 - new first element
    
    e3 - new third element
    
    Returns:
    
    tuple with exchanged elements
  - x23
```
@NotNull
public <E2,E3> NTuple4<T1,E2,E3,T4> x23(@Nullable
                                                 E2 e2,
                                                 @Nullable
                                                 E3 e3)
```
    Create a 4-tuple from this one where the second and third elements are exchanged.
    
    Type Parameters:
    
    E2 - type of exchanged second element
    
    E3 - type of exchanged third element
    
    Parameters:
    
    e2 - new second element
    
    e3 - new third element
    
    Returns:
    
    tuple with exchanged elements
  - x14
```
@NotNull
public <E1,E4> NTuple4<E1,T2,T3,E4> x14(@Nullable
                                                 E1 e1,
                                                 @Nullable
                                                 E4 e4)
```
    Create a 4-tuple from this one where the first and fourth elements are exchanged.
    
    Type Parameters:
    
    E1 - type of exchanged first element
    
    E4 - type of exchanged fourth element
    
    Parameters:
    
    e1 - new first element
    
    e4 - new fourth element
    
    Returns:
    
    tuple with exchanged elements
  - x24
```
@NotNull
public <E2,E4> NTuple4<T1,E2,T3,E4> x24(@Nullable
                                                 E2 e2,
                                                 @Nullable
                                                 E4 e4)
```
    Create a 4-tuple from this one where the second and fourth elements are exchanged.
    
    Type Parameters:
    
    E2 - type of exchanged second element
    
    E4 - type of exchanged fourth element
    
    Parameters:
    
    e2 - new second element
    
    e4 - new fourth element
    
    Returns:
    
    tuple with exchanged elements
  - x34
```
@NotNull
public <E3,E4> NTuple4<T1,T2,E3,E4> x34(@Nullable
                                                 E3 e3,
                                                 @Nullable
                                                 E4 e4)
```
    Create a 4-tuple from this one where the third and fourth elements are exchanged.
    
    Type Parameters:
    
    E3 - type of exchanged third element
    
    E4 - type of exchanged fourth element
    
    Parameters:
    
    e3 - new third element
    
    e4 - new fourth element
    
    Returns:
    
    tuple with exchanged elements
  - x123
```
@NotNull
public <E1,E2,E3> NTuple4<E1,E2,E3,T4> x123(@Nullable
                                                     E1 e1,
                                                     @Nullable
                                                     E2 e2,
                                                     @Nullable
                                                     E3 e3)
```
    Create a 4-tuple from this one where the first, second, and thirdelements are exchanged.
    
    Type Parameters:
    
    E1 - type of exchanged first element
    
    E2 - type of exchanged second element
    
    E3 - type of exchanged third element
    
    Parameters:
    
    e1 - new first element
    
    e2 - new second element
    
    e3 - new third element
    
    Returns:
    
    tuple with exchanged elements
  - x124
```
@NotNull
public <E1,E2,E4> NTuple4<E1,E2,T3,E4> x124(@Nullable
                                                     E1 e1,
                                                     @Nullable
                                                     E2 e2,
                                                     @Nullable
                                                     E4 e4)
```
    Create a 4-tuple from this one where the first, second, and fourthelements are exchanged.
    
    Type Parameters:
    
    E1 - type of exchanged first element
    
    E2 - type of exchanged second element
    
    E4 - type of exchanged fourth element
    
    Parameters:
    
    e1 - new first element
    
    e2 - new second element
    
    e4 - new fourth element
    
    Returns:
    
    tuple with exchanged elements
  - x134
```
@NotNull
public <E1,E3,E4> NTuple4<E1,T2,E3,E4> x134(@Nullable
                                                     E1 e1,
                                                     @Nullable
                                                     E3 e3,
                                                     @Nullable
                                                     E4 e4)
```
    Create a 4-tuple from this one where the first, third, and fourthelements are exchanged.
    
    Type Parameters:
    
    E1 - type of exchanged first element
    
    E3 - type of exchanged third element
    
    E4 - type of exchanged fourth element
    
    Parameters:
    
    e1 - new first element
    
    e3 - new third element
    
    e4 - new fourth element
    
    Returns:
    
    tuple with exchanged elements
  - x234
```
@NotNull
public <E2,E3,E4> NTuple4<T1,E2,E3,E4> x234(@Nullable
                                                     E2 e2,
                                                     @Nullable
                                                     E3 e3,
                                                     @Nullable
                                                     E4 e4)
```
    Create a 4-tuple from this one where the second, third, and fourthelements are exchanged.
    
    Type Parameters:
    
    E2 - type of exchanged second element
    
    E3 - type of exchanged third element
    
    E4 - type of exchanged fourth element
    
    Parameters:
    
    e2 - new second element
    
    e3 - new third element
    
    e4 - new fourth element
    
    Returns:
    
    tuple with exchanged elements
  - i1
```
@NotNull
public <T> NTuple5<T,T1,T2,T3,T4> i1(@Nullable
                                              T e1)
```
    Create a 5-tuple from this 4-tuple by inserting a new first element.
    
    Type Parameters:
    
    T - new element type
    
    Parameters:
    
    e1 - new element
    
    Returns:
    
    5-tuple
  - i2
```
@NotNull
public <T> NTuple5<T1,T,T2,T3,T4> i2(@Nullable
                                              T e2)
```
    Create a 5-tuple from this 4-tuple by inserting a new second element.
    
    Type Parameters:
    
    T - new element type
    
    Parameters:
    
    e2 - new element
    
    Returns:
    
    5-tuple
  - i3
```
@NotNull
public <T> NTuple5<T1,T2,T,T3,T4> i3(@Nullable
                                              T e3)
```
    Create a 5-tuple from this 4-tuple by inserting a new third element.
    
    Type Parameters:
    
    T - new element type
    
    Parameters:
    
    e3 - new element
    
    Returns:
    
    5-tuple
  - i4
```
@NotNull
public <T> NTuple5<T1,T2,T3,T,T4> i4(@Nullable
                                              T e4)
```
    Create a 5-tuple from this 4-tuple by inserting a new fourth element.
    
    Type Parameters:
    
    T - new element type
    
    Parameters:
    
    e4 - new element
    
    Returns:
    
    5-tuple
  - i5
```
@NotNull
public <T> NTuple5<T1,T2,T3,T4,T> i5(@Nullable
                                              T e5)
```
    Create a 5-tuple from this 4-tuple by adding a new fifth element.
    
    Type Parameters:
    
    T - new element type
    
    Parameters:
    
    e5 - new element
    
    Returns:
    
    5-tuple
  - toString
```
@NotNull
public java.lang.String toString()
```
    Overrides:
    
    toString in class ITuple4.Base<T1,T2,T3,T4>

Class NTuple4<T1,T2,T3,T4>

Nested Class Summary

Nested classes/interfaces inherited from interface de.caff.generics.tuple.ITuple4

Constructor Summary

Method Summary

Methods inherited from class de.caff.generics.tuple.ITuple4.Base

Methods inherited from class java.lang.Object

Methods inherited from interface de.caff.generics.tuple.ITuple4

Constructor Detail

NTuple4

Method Detail

_1

_2

_3

_4

_1243

_1423

_4123

_4132

_1432

_1342

_1324

_3124

_3142

_3412

_4312

_4321

_3421

_3241

_3214

_2314

_2341

_2431

_4231

_4213

_2413

_2143

_2134

_123

_132

_312

_321

_231

_213

_124

_142

_412

_421

_241

_214

_134

_143

_413

_431

_341

_314

_234

_243

_423

_432

_342

_324

_12

_21

_13

_31

_23

_32

_14

_41

_24

_42

_34

_43

frozen

x1

x2

x3

x4

x12