org.apache.commons.lang3.tuple

## Class MutablePair<L,R>

- java.lang.Object
- - org.apache.commons.lang3.tuple.Pair<L,R>
  - - org.apache.commons.lang3.tuple.MutablePair<L,R>

- Type Parameters:
    `L` - the left element type
    `R` - the right element type
  All Implemented Interfaces:
    Serializable, Comparable<Pair<L,R>>, Map.Entry<L,R>

      public class MutablePair<L,R>
      extends Pair<L,R>

  A mutable pair consisting of two `Object` elements.

  Not #ThreadSafe#

  Since:
    3.0
  See Also:
    Serialized Form

- - ### Field Summary

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

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MutablePair()` Create a new pair instance of two nulls.
    `MutablePair(L left, R right)` Create a new pair instance.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <L,R> MutablePair<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> MutablePair<L,R>` | `of(L left, R right)` Creates a mutable pair of two objects inferring the generic types.
    `static <L,R> MutablePair<L,R>` | `of(Map.Entry<L,R> pair)` Creates a mutable pair from an existing pair.
    `void` | `setLeft(L left)` Sets the left element of the pair.
    `void` | `setRight(R right)` Sets the right element of the pair.
    `R` | `setValue(R value)` Sets the `Map.Entry` value.

    - ### Methods inherited from class org.apache.commons.lang3.tuple.Pair

      `compareTo, equals, getKey, getValue, hashCode, toString, toString`

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

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

    - ### Methods inherited from interface java.util.Map.Entry

      `comparingByKey, comparingByKey, comparingByValue, comparingByValue`

- - ### Field Detail

    - #### EMPTY_ARRAY

          public static final MutablePair<?,?>[] EMPTY_ARRAY

      An empty array.

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

      Since:
        3.10.

    - #### left

          public L left

      Left object

    - #### right

          public R right

      Right object

  - ### Constructor Detail

    - #### MutablePair

          public MutablePair()

      Create a new pair instance of two nulls.

    - #### MutablePair

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

    - #### of

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

      Creates a mutable 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> MutablePair<L,R> of(Map.Entry<L,R> pair)

      Creates a mutable 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

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

    - #### setLeft

          public void setLeft(L left)

      Sets the left element of the pair.
      Parameters:
        `left` - the new value of the left element, may be null

    - #### setRight

          public void setRight(R right)

      Sets the right element of the pair.
      Parameters:
        `right` - the new value of the right element, may be null

    - #### setValue

          public R setValue(R value)

      Sets the `Map.Entry` value. This sets the right element of the pair.
      Parameters:
        `value` - the right value to set, not null
      Returns:
        the old value for the right element

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