L
- the left element typeR
- the right element typepublic 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() |
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, wait
comparingByKey, comparingByKey, comparingByValue, comparingByValue, setValue
public static final Pair<?,?>[] EMPTY_ARRAY
Consider using emptyArray()
to avoid generics warnings.
public Pair()
public static <L,R> Pair<L,R>[] emptyArray()
L
- the left element typeR
- the right element typepublic 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 typeR
- the right element typeleft
- the left element, may be nullright
- the right element, may be nullpublic 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 typeR
- the right element typepair
- 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 typeR
- the right element typeleft
- the left element, may not be nullright
- the right element, may not be nullNullPointerException
- if any input is nullpublic <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 Throwable
public <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 Throwable
public int compareTo(Pair<L,R> other)
Comparable
.compareTo
in interface Comparable<Pair<L,R>>
other
- the other pair, not nullpublic 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()
Map.Entry
.public String toString()
($left,$right)
.public String toString(String format)
This uses Formattable
to perform the formatting. 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).
The default format used by toString()
is (%1$s,%2$s)
.
format
- the format string, optionally containing %1$s
and %2$s
, not nullCopyright © 2001–2023 The Apache Software Foundation. All rights reserved.