org.apache.commons.lang3.tuple

## Class ImmutableTriple<L,M,R>

- java.lang.Object
- - org.apache.commons.lang3.tuple.Triple<L,M,R>
  - - org.apache.commons.lang3.tuple.ImmutableTriple<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 final class ImmutableTriple<L,M,R>
      extends Triple<L,M,R>

  An immutable triple consisting of three `Object` elements.

  Although the implementation is immutable, there is no restriction on the objects that may be stored. If mutable objects are stored in the triple, then the triple itself effectively becomes mutable. The class is also `final`, so a subclass can not add undesirable behaviour.

  #ThreadSafe# if all three objects are thread-safe

  Since:
    3.2
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static ImmutableTriple<?,?,?>[]` | `EMPTY_ARRAY` An empty array.
    `L` | `left` Left object
    `M` | `middle` Middle object
    `R` | `right` Right object

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ImmutableTriple(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> ImmutableTriple<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> ImmutableTriple<L,M,R>` | `nullTriple()` Returns an immutable triple of nulls.
    `static <L,M,R> ImmutableTriple<L,M,R>` | `of(L left, M middle, R right)` Obtains an immutable triple of three objects inferring the generic types.

    - ### 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 ImmutableTriple<?,?,?>[] EMPTY_ARRAY

      An empty array.

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

      Since:
        3.10.

    - #### left

          public final L left

      Left object

    - #### middle

          public final M middle

      Middle object

    - #### right

          public final R right

      Right object

  - ### Constructor Detail

    - #### ImmutableTriple

          public ImmutableTriple(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> ImmutableTriple<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.

    - #### nullTriple

          public static <L,M,R> ImmutableTriple<L,M,R> nullTriple()

      Returns an immutable triple of nulls.
      Type Parameters:
        `L` - the left element of this triple. Value is `null`.
        `M` - the middle element of this triple. Value is `null`.
        `R` - the right element of this triple. Value is `null`.
      Returns:
        an immutable triple of nulls.
      Since:
        3.6

    - #### of

          public static <L,M,R> ImmutableTriple<L,M,R> of(L left,
                                                          M middle,
                                                          R right)

      Obtains an immutable 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

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