Package 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:
  `java.io.Serializable`, `java.lang.Comparable<Pair<L,​R>>`, `java.util.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
`static MutablePair<?,​?>[]` `EMPTY_ARRAY` An empty array.
`L` `left` Left object
`R` `right` Right object

### Constructor Summary

Constructors
`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
`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​(java.util.Map.Entry<L,​R> pair)` Creates a mutable pair from an existing pair.
`static <L,​R> MutablePair<L,​R>` `of​(L left, R right)` Creates a mutable pair of two objects inferring the generic types.
`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`

### 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​(java.util.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