Pairs in Java

Learn to work with key value pairs in Java using Pair classes e.g. javafx.util.Pair, ImmutablePair, MmutablePair (common langs) and io.vavr.Tuple2 class.

Read More : Tuples in Java

1. Why we need pairs?

A pair provide a convenient way of associating a simple key to value. In Java, maps are used to store key-value pairs. Maps store a collection of pairs and operate them as a whole.

Sometimes, we need to work on requirements where a key-value pair shall exist on it’s own. e.g.

  • A pair need to be passed in a method as argument
  • Method need to return two values in form of a pair

2. javafx.util.Pair class

Java core APIs have javafx.util.Pair as closest match which serve the purpose of having two values as name-value pair. Follow this link to learn to add JavaFx support in eclipse.

Pair class provides following methods.

  • boolean equals​(Object o) – Test this Pair for equality with another Object.
  • K getKey() – Gets the key for this pair.
  • V getValue() – Gets the value for this pair.
  • int hashCode() – Generate a hash code for this Pair.
  • String toString() – String representation of this Pair.

Let’s see a java program to create and use pair.

Pair<Integer, String> pair = new Pair<>(100, "");
Integer key = pair.getKey();		//100
String value = pair.getValue();		//

pair.equals(new Pair<>(100, ""));	//true - same name and value

pair.equals(new Pair<>(222, ""));	//false	- different name

pair.equals(new Pair<>(100, ""));		//false	- different value

3. Pair, ImmutablePair and MutablePair – Apache commons lang

Commons lang library has a useful class which can used as pair i.e. org.apache.commons.lang3.tuple.Pair. It has two subclasses which can also be used for same purpose i.e. ImmutablePair and MutablePair.

  • Pair class is a pair consisting of two elements.
  • Pair refers to the elements as ‘left’ and ‘right’.
  • Pair also implements the Map.Entry interface where the key is ‘left’ and the value is ‘right’.
  • ImmutablePair is immutable representation on Pair. If mutable objects are stored in the pair, then the pair itself effectively becomes mutable. The class is also not final, so a subclass could add undesirable behavior.
  • ImmutablePair is thread-safe if the stored objects are thread-safe.
ImmutablePair<Integer, String> pair = ImmutablePair.of(100, "");
Integer key = pair.getKey();			//100
String value = pair.getValue();			//

//Integer key = pair.getLeft();			//100
//String value = pair.getRight();		//

pair.equals(ImmutablePair.of(100, ""));	//true - same name and value

pair.equals(ImmutablePair.of(222, ""));	//false	- different name

pair.equals(ImmutablePair.of(100, ""));		//false	- different value

Do not forget to import the library into application classpath.


4. io.vavr.Tuple2 – Vavr

Another useful class for storing key-value pair is Tuple2.

Tuple2 provide lots of useful method to work on data stored in it. e.g.

  • T1 _1() – Getter of the 1st element of this tuple.
  • T2 _2() – Getter of the 2nd element of this tuple.
  • Tuple2 update1(T1 value) – Sets the 1st element of this tuple to the given value.
  • Tuple2 update2(T2 value) – Sets the 2nd element of this tuple to the given value.
  • Map.Entry toEntry() – Converts the tuple to java.util.Map.Entry Tuple.
  • Tuple2 swap() – Swaps the elements of this Tuple.
  • Tuple2 map(BiFunction mapper) – Maps the components of this tuple using a mapper function.
  • int compareTo(Tuple2 that) – Compare two Tuple2 instances.
Tuple2<Integer, String> pair = new Tuple2<>(100, "");
Integer key = pair._1();			//100
String value = pair._2();			//

pair.equals(new Tuple2<>(100, ""));	//true - same name and value

pair.equals(new Tuple2<>(222, ""));	//false	- different name

pair.equals(new Tuple2<>(100, ""));		//false	- different value

Do not forget to import the library into application classpath.


Drop me your questions related to working with name-value pairs in Java.

Happy Learning !!


Notify of
Inline Feedbacks
View all comments

About Us

HowToDoInJava provides tutorials and how-to guides on Java and related technologies.

It also shares the best practices, algorithms & solutions and frequently asked interview questions.