Package org.apache.commons.lang3.tuple

Class ImmutableTriple<L,​M,​R>

  • Type Parameters:
    L - the left element type
    M - the middle element type
    R - the right element type
    All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<Triple<L,​M,​R>>
    public 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 behavior.

    #ThreadSafe# if all three objects are thread-safe

    Since:
    3.2
    See Also:
    Serialized Form

    • Constructor Summary

      Constructors 
      Constructor 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 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.
      static <L,​M,​R>
      ImmutableTriple<L,​M,​R>      		 ofNonNull​(L left, M middle, R right)
      Obtains an immutable triple of three non-null objects inferring the generic types.

      • Methods inherited from class java.lang.Object

        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

      • ofNonNull

        public static <L,​M,​R> ImmutableTriple<L,​M,​R> ofNonNull​(L left,
                                                                               M middle,
                                                                               R right)
        Obtains an immutable 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:
        java.lang.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