L - the left element type.R - the right element type.public abstract class Pair<L,R> extends Object implements Map.Entry<L,R>, Comparable<Pair<L,R>>, Serializable
This class is an abstract implementation defining the basic API.
It refers to the elements as 'left' and 'right'. It also implements the
Map.Entry interface where the key is 'left' and the value is 'right'.
Subclass implementations may be mutable or immutable. However, there is no restriction on the type of the stored objects that may be stored. If mutable objects are stored in the pair, then the pair itself effectively becomes mutable.
| Modifier and Type | Field and Description |
|---|---|
static Pair<?,?>[] |
EMPTY_ARRAY
An empty array.
|
| Constructor and Description |
|---|
Pair()
Constructs a new instance.
|
| Modifier and Type | Method and Description |
|---|---|
<E extends Throwable> |
accept(FailableBiConsumer<L,R,E> consumer)
Accepts this key and value as arguments to the given consumer.
|
<V,E extends Throwable> |
apply(FailableBiFunction<L,R,V,E> function)
Applies this key and value as arguments to the given function.
|
int |
compareTo(Pair<L,R> other)
Compares the pair based on the left element followed by the right element.
|
static <L,R> Pair<L,R>[] |
emptyArray()
Returns the empty array singleton that can be assigned without compiler warning.
|
boolean |
equals(Object obj)
Compares this pair to another based on the two elements.
|
L |
getKey()
Gets the key from this pair.
|
abstract L |
getLeft()
Gets the left element from this pair.
|
abstract R |
getRight()
Gets the right element from this pair.
|
R |
getValue()
Gets the value from this pair.
|
int |
hashCode()
Returns a suitable hash code.
|
static <L,R> Pair<L,R> |
of(L left,
R right)
Creates an immutable pair of two objects inferring the generic types.
|
static <L,R> Pair<L,R> |
of(Map.Entry<L,R> pair)
Creates an immutable pair from a map entry.
|
static <L,R> Pair<L,R> |
ofNonNull(L left,
R right)
Creates an immutable pair of two non-null objects inferring the generic types.
|
String |
toString()
Returns a String representation of this pair using the format
(left,right). |
String |
toString(String format)
Formats the receiver using the given format.
|
clone, finalize, getClass, notify, notifyAll, wait, wait, waitcomparingByKey, comparingByKey, comparingByValue, comparingByValue, setValuepublic static final Pair<?,?>[] EMPTY_ARRAY
Consider using emptyArray() to avoid generics warnings.
public static <L,R> Pair<L,R>[] emptyArray()
L - the left element type.R - the right element type.public static <L,R> Pair<L,R> of(L left, R right)
This factory allows the pair to be created using inference to obtain the generic types.
L - the left element type.R - the right element type.left - the left element, may be null.right - the right element, may be null.public static <L,R> Pair<L,R> of(Map.Entry<L,R> pair)
This factory allows the pair to be created using inference to obtain the generic types.
L - the left element type.R - the right element type.pair - the map entry.public static <L,R> Pair<L,R> ofNonNull(L left, R right)
This factory allows the pair to be created using inference to obtain the generic types.
L - the left element type.R - the right element type.left - the left element, may not be null.right - the right element, may not be null.NullPointerException - if any input is null.public <E extends Throwable> void accept(FailableBiConsumer<L,R,E> consumer) throws E extends Throwable
E - The kind of thrown exception or error.consumer - the consumer to call.E - Thrown when the consumer fails.E extends Throwablepublic <V,E extends Throwable> V apply(FailableBiFunction<L,R,V,E> function) throws E extends Throwable
V - The function return type.E - The kind of thrown exception or error.function - the consumer to call.E - Thrown when the consumer fails.E extends Throwablepublic int compareTo(Pair<L,R> other)
Comparable.compareTo in interface Comparable<Pair<L,R>>other - the other pair, not null.public boolean equals(Object obj)
public final L getKey()
This method implements the Map.Entry interface returning the
left element as the key.
public abstract L getLeft()
When treated as a key-value pair, this is the key.
public abstract R getRight()
When treated as a key-value pair, this is the value.
public R getValue()
This method implements the Map.Entry interface returning the
right element as the value.
public int hashCode()
The hash code follows the definition in Map.Entry.
public String toString()
(left,right).public String toString(String format)
This uses String.format(String, Object...) to the format. Two variables may be used to embed the left and right elements. Use %1$s for
the left element (key) and %2$s for the right element (value).
format - the format string, optionally containing %1$s and %2$s, not null.String.format(String, Object...)Copyright © 2001–2025 The Apache Software Foundation. All rights reserved.