Package org.apache.commons.lang3.tuple

## Class MutableTriple<L,​M,​R>

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

A mutable triple consisting of three `Object` elements.

Not #ThreadSafe#

Since:
  3.2
See Also:
  Serialized Form

### Field Summary

Fields
`static MutableTriple<?,​?,​?>[]` `EMPTY_ARRAY` The empty array singleton.
`L` `left` Left object
`M` `middle` Middle object
`R` `right` Right object

### Constructor Summary

Constructors
`MutableTriple()` Create a new triple instance of three nulls.
`MutableTriple​(L left, M middle, R right)` Create a new triple instance.

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`static <L,​M,​R> MutableTriple<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> MutableTriple<L,​M,​R>` `of​(L left, M middle, R right)` Obtains a mutable triple of three objects inferring the generic types.
`void` `setLeft​(L left)` Sets the left element of the triple.
`void` `setMiddle​(M middle)` Sets the middle element of the triple.
`void` `setRight​(R right)` Sets the right element of the triple.

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

The empty array singleton.

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

Since:
  3.10.

#### left

    public L left

Left object

#### middle

    public M middle

Middle object

#### right

    public R right

Right object

### Constructor Detail

#### MutableTriple

    public MutableTriple()

Create a new triple instance of three nulls.

#### MutableTriple

    public MutableTriple​(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> MutableTriple<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.

#### of

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

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

#### setLeft

    public void setLeft​(L left)

Sets the left element of the triple.

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

#### setMiddle

    public void setMiddle​(M middle)

Sets the middle element of the triple.

Parameters:
  `middle` - the new value of the middle element, may be null

#### setRight

    public void setRight​(R right)

Sets the right element of the triple.

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