Package org.apache.commons.lang3.tuple

Class ImmutablePair<L,​R>

  • Type Parameters:
    L - the left element type
    R - the right element type
    All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<Pair<L,​R>>, java.util.Map.Entry<L,​R>
    public final class ImmutablePair<L,​R>
extends Pair<L,​R>

    An immutable pair consisting of two 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 pair, then the pair itself effectively becomes mutable. The class is also final, so a subclass can not add undesirable behavior.

    #ThreadSafe# if both paired objects are thread-safe

    Since:
    3.0
    See Also:
    Serialized Form

    • Constructor Summary

      Constructors 
      Constructor Description
      ImmutablePair​(L left, R right)
      Create a new pair instance.

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      static <L,​R>
      ImmutablePair<L,​R>[]      		 emptyArray()
      Returns the empty array singleton that can be assigned without compiler warning.
      L getLeft()
      Gets the left element from this pair.
      R getRight()
      Gets the right element from this pair.
      static <L,​R>
      Pair<L,​R>      		 left​(L left)
      Creates an immutable pair of two objects inferring the generic types.
      static <L,​R>
      ImmutablePair<L,​R>      		 nullPair()
      Returns an immutable pair of nulls.
      static <L,​R>
      ImmutablePair<L,​R>      		 of​(java.util.Map.Entry<L,​R> pair)
      Creates an immutable pair from an existing pair.
      static <L,​R>
      ImmutablePair<L,​R>      		 of​(L left, R right)
      Creates an immutable pair of two objects inferring the generic types.
      static <L,​R>
      Pair<L,​R>      		 right​(R right)
      Creates an immutable pair of two objects inferring the generic types.
      R setValue​(R value)
      Throws UnsupportedOperationException.

      • Methods inherited from class java.lang.Object

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

    • Field Detail

      • EMPTY_ARRAY

        public static final ImmutablePair<?,​?>[] EMPTY_ARRAY
        An empty array.

        Consider using emptyArray() to avoid generics warnings.

        Since:
        3.10.

      • left

        public final L left
        Left object

      • right

        public final R right
        Right object

    • Constructor Detail

      • ImmutablePair

        public ImmutablePair​(L left,
                     R right)
        Create a new pair instance.
        Parameters:
        left - the left value, may be null
        right - the right value, may be null

    • Method Detail

      • emptyArray

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

      • left

        public static <L,​R> Pair<L,​R> left​(L left)

        Creates an immutable pair of two objects inferring the generic types.

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

        Type Parameters:
        L - the left element type
        R - the right element type
        Parameters:
        left - the left element, may be null
        Returns:
        a pair formed from the two parameters, not null
        Since:
        3.11

      • nullPair

        public static <L,​R> ImmutablePair<L,​R> nullPair()
        Returns an immutable pair of nulls.
        Type Parameters:
        L - the left element of this pair. Value is null.
        R - the right element of this pair. Value is null.
        Returns:
        an immutable pair of nulls.
        Since:
        3.6

      • of

        public static <L,​R> ImmutablePair<L,​R> of​(L left,
                                                      R right)

        Creates an immutable pair of two objects inferring the generic types.

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

        Type Parameters:
        L - the left element type
        R - the right element type
        Parameters:
        left - the left element, may be null
        right - the right element, may be null
        Returns:
        a pair formed from the two parameters, not null

      • of

        public static <L,​R> ImmutablePair<L,​R> of​(java.util.Map.Entry<L,​R> pair)

        Creates an immutable pair from an existing pair.

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

        Type Parameters:
        L - the left element type
        R - the right element type
        Parameters:
        pair - the existing pair.
        Returns:
        a pair formed from the two parameters, not null
        Since:
        3.10

      • right

        public static <L,​R> Pair<L,​R> right​(R right)

        Creates an immutable pair of two objects inferring the generic types.

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

        Type Parameters:
        L - the left element type
        R - the right element type
        Parameters:
        right - the right element, may be null
        Returns:
        a pair formed from the two parameters, not null
        Since:
        3.11

      • getLeft

        public L getLeft()

        Gets the left element from this pair.

        When treated as a key-value pair, this is the key.

        Specified by:
        getLeft in class Pair<L,​R>
        Returns:
        the left element, may be null

      • getRight

        public R getRight()

        Gets the right element from this pair.

        When treated as a key-value pair, this is the value.

        Specified by:
        getRight in class Pair<L,​R>
        Returns:
        the right element, may be null

      • setValue

        public R setValue​(R value)

        Throws UnsupportedOperationException.

        This pair is immutable, so this operation is not supported.

        Parameters:
        value - the value to set
        Returns:
        never
        Throws:
        java.lang.UnsupportedOperationException - as this operation is not supported