Package org.apache.commons.lang3.tuple

# Class MutableTriple<L,M,R>

java.lang.Object
org.apache.commons.lang3.tuple.Triple<L,M,R>
org.apache.commons.lang3.tuple.MutableTriple<L,M,R>

Type Parameters:
  `L` - the left element type.
  `M` - the middle element type.
  `R` - the right element type.

All Implemented Interfaces:
  `Serializable`, `Comparable<Triple<L,M,R>>`

public class MutableTriple<L,M,R> extends Triple<L,M,R>
A mutable triple consisting of three `Object` elements.

Not #ThreadSafe#

Since:
  3.2
See Also:
  - Serialized Form

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final MutableTriple<?,?,?>[]`
  `EMPTY_ARRAY`
  The empty array singleton.
  `L`
  `left`
  Left object.
  `M`
  `middle`
  Middle object.
  `R`
  `right`
  Right object.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `MutableTriple()`
  Create a new triple instance of three nulls.
  `MutableTriple(L left, M middle, R right)`
  Create a new triple instance.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static <L, M, R> MutableTriple<L,M,R>[]`
  `emptyArray()`
  Returns the empty array singleton that can be assigned without compiler warning.
  `L`
  `getLeft()`
  Gets the left element from this triple.
  `M`
  `getMiddle()`
  Gets the middle element from this triple.
  `R`
  `getRight()`
  Gets the right element from this triple.
  `static <L, M, R> MutableTriple<L,M,R>`
  `of(L left, M middle, R right)`
  Obtains a mutable triple of three objects inferring the generic types.
  `static <L, M, R> MutableTriple<L,M,R>`
  `ofNonNull(L left, M middle, R right)`
  Obtains a mutable triple of three non-null objects inferring the generic types.
  `void`
  `setLeft(L left)`
  Sets the left element of the triple.
  `void`
  `setMiddle(M middle)`
  Sets the middle element of the triple.
  `void`
  `setRight(R right)`
  Sets the right element of the triple.

  ### Methods inherited from class org.apache.commons.lang3.tuple.Triple

  `compareTo, equals, hashCode, toString, toString`

  ### Methods inherited from class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- ## Field Details

  - ### EMPTY_ARRAY

    public static final MutableTriple<?,?,?>[] EMPTY_ARRAY
    The empty array singleton.

    Consider using `emptyArray()` to avoid generics warnings.

    Since:
      3.10

  - ### left

    public L left
    Left object.

  - ### middle

    public M middle
    Middle object.

  - ### right

    public R right
    Right object.

- ## Constructor Details

  - ### MutableTriple

    public MutableTriple()
    Create a new triple instance of three nulls.

  - ### MutableTriple

    public MutableTriple(L left, M middle, R right)
    Create a new triple instance.
    Parameters:
      `left` - the left value, may be null.
      `middle` - the middle value, may be null.
      `right` - the right value, may be null.

- ## Method Details

  - ### emptyArray

    public static <L, M, R> MutableTriple<L,M,R>[] emptyArray()
    Returns the empty array singleton that can be assigned without compiler warning.
    Type Parameters:
      `L` - the left element type.
      `M` - the middle element type.
      `R` - the right element type.
    Returns:
      the empty array singleton that can be assigned without compiler warning.
    Since:
      3.10

  - ### of

    public static <L, M, R> MutableTriple<L,M,R> of(L left, M middle, R right)
    Obtains a mutable triple of three objects inferring the generic types.

    This factory allows the triple to be created using inference to obtain the generic types.

    Type Parameters:
      `L` - the left element type.
      `M` - the middle element type.
      `R` - the right element type.
    Parameters:
      `left` - the left element, may be null.
      `middle` - the middle element, may be null.
      `right` - the right element, may be null.
    Returns:
      a triple formed from the three parameters, not null.

  - ### ofNonNull

    public static <L, M, R> MutableTriple<L,M,R> ofNonNull(L left, M middle, R right)
    Obtains a mutable triple of three non-null objects inferring the generic types.

    This factory allows the triple to be created using inference to obtain the generic types.

    Type Parameters:
      `L` - the left element type.
      `M` - the middle element type.
      `R` - the right element type.
    Parameters:
      `left` - the left element, may not be null.
      `middle` - the middle element, may not be null.
      `right` - the right element, may not be null.
    Returns:
      a triple formed from the three parameters, not null.
    Throws:
      `NullPointerException` - if any input is null.
    Since:
      3.13.0

  - ### getLeft

    public L getLeft()
    Gets the left element from this triple.
    Specified by:
      `getLeft` in class `Triple<L,M,R>`
    Returns:
      the left element, may be null.

  - ### getMiddle

    public M getMiddle()
    Gets the middle element from this triple.
    Specified by:
      `getMiddle` in class `Triple<L,M,R>`
    Returns:
      the middle element, may be null.

  - ### getRight

    public R getRight()
    Gets the right element from this triple.
    Specified by:
      `getRight` in class `Triple<L,M,R>`
    Returns:
      the right element, may be null.

  - ### setLeft

    public void setLeft(L left)
    Sets the left element of the triple.
    Parameters:
      `left` - the new value of the left element, may be null.

  - ### setMiddle

    public void setMiddle(M middle)
    Sets the middle element of the triple.
    Parameters:
      `middle` - the new value of the middle element, may be null.

  - ### setRight

    public void setRight(R right)
    Sets the right element of the triple.
    Parameters:
      `right` - the new value of the right element, may be null.