Pair Class in Java

Accessing Values from a Pair

Once we create a Pair, we often need to retrieve the stored values. The Pair class provides two simple methods for this:

1. getKey() – Gets the First Value

This method returns the first element (key) of the pair.

2. getValue() – Gets the Second Value

This method returns the second element (value) of the pair.

Example

import javafx.util.Pair;  


public class Main {  
    public static void main(String[] args) {  
        // Creating a Pair of String (Name) & Integer (Age)  
        Pair<String, Integer> person = new Pair<>("Priya", 22);  


        // Accessing values  
        String name = person.getKey();  
        int age = person.getValue();  


        System.out.println("Name: " + name);  
        System.out.println("Age: " + age);  
    }  
}  

You can also try this code with Online Java Compiler

Run Code

Output:

Name: Priya  
Age: 22  

When would we use this?

• If we need to process the key & value separately (e.g., printing, calculations).
   
• When passing a pair to a method & extracting its values inside.

Alternative Implementations of Pair in Java

The javafx.util.Pair class is not the only way to store two values together. Let’s look at other options:

1. Using AbstractMap.SimpleEntry (from java.util)

This is another built-in way to store key-value pairs.

Example:

import java.util.AbstractMap;  
public class Main {  
    public static void main(String[] args) {  
        AbstractMap.SimpleEntry<String, Integer> student =  
            new AbstractMap.SimpleEntry<>("Rohit", 30);  


        System.out.println("Student: " + student.getKey() + ", Marks: " + student.getValue());  
    }  
}  

You can also try this code with Online Java Compiler

Run Code

Output:

Student: Rohit, Marks: 30  

2. Using a Custom Class

If we need more flexibility, we can create our own Pair class.

Example:

class CustomPair<K, V> {  
    private K key;  
    private V value;  


    public CustomPair(K key, V value) {  
        this.key = key;  
        this.value = value;  
    }  

    public K getKey() { return key; }  
    public V getValue() { return value; }  
}  


public class Main {  
    public static void main(String[] args) {  
        CustomPair<String, Double> product = new CustomPair<>("Mouse", 12.99);  
        System.out.println(product.getKey() + " costs $" + product.getValue());  
    }  
}  

You can also try this code with Online Java Compiler

Run Code

Output:

Mouse costs $12.99  

Which one to use?

• javafx.util.Pair → Simple & quick for basic needs.
   
• SimpleEntry → Useful if working with Java Collections.
   
• Custom Class → Best when we need extra methods or modifications.

Why Do We Need the Pair Class?

There are some cases when we need to store temporarily two values, not belonging to another type but somehow connected. Where does Pair come in handy?

• Avoids Extra Classes  - To put two values into a class, rather than creating a Student or Product class, we use Pair.
   
• Eases Code- Can be used where a method requires that it returns two values (Java does not permit multiple returns).
   
• Objects that handle Collections - Handy in List<Pair>, Map entries, etc.

Example Use Case

import javafx.util.Pair;  
import java.util.ArrayList;  
import java.util.List;  


public class Main {  
    public static void main(String[] args) {  
        List<Pair<String, Integer>> students = new ArrayList<>();  
        students.add(new Pair<>("Amit", 85));  
        students.add(new Pair<>("Neha", 92));  


        for (Pair<String, Integer> student : students) {  
            System.out.println(student.getKey() + " scored " + student.getValue());  
        }  
    }  
}  

You can also try this code with Online Java Compiler

Run Code

Output

Amit scored 85  
Neha scored 92 

Frequently Asked Questions

Does Pair have more capability to store than two values?

No, there are only two in Pair. To work with more values, make use of a custom class or Triple (provided by such libraries as Apache Commons).

Is Pair thread safe?

No. Use synchronization where you want several threads accessing it.

What are the times I should not use Pair?

Use when values have no association with each-other or when additional technique is required (use custom class instead).

Conclusion

Here, we have come to know that Pair class in Java offers an easy mechanism of storing two values in a single construct. We provided details of its operations such as getKey() and getValue() and juxtaposed it with an alternative such as SimpleEntry and discussed applicability. It is more useful when dealing with short term storage of similar information, but in a non trivial case, one should use custom classes instead of the collection class. When you require the rapid collection of two values with nil added cost, the Pair class assists you maintain your code clean.