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 and Description
    --- | ---
    `static MutableTriple<?,?,?>[]` | `EMPTY_ARRAY` The empty array singleton.
    `L` | `left` Left object
    `M` | `middle` Middle object
    `R` | `right` Right object

  - ### Constructor Summary

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

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and 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.
    `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 Detail

    - #### 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 Detail

    - #### 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 Detail

    - #### 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

    - #### 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

Copyright © 2001–2021 The Apache Software Foundation. All rights reserved.