A KeyValuePair in Java

java

pair

map-entry

java-utility-classes

byAlex Kataev·Sep 5, 2024

Here's a quick implementation of a Pair class in Java for key-value storage:

public class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
        // Because key-value pairs go together like peanut butter and jelly!
        this.key = key;
        this.value = value; 
    }
    // Send out the search party! Here's how to find your key.
    public K getKey() { return key; }
    // No secrets here, let's reveal the value.
    public V getValue() { return value; }
}

Put it into action:

Pair<Integer, String> myPair = new Pair<>(1, "One");

Access its elements:

Integer key = myPair.getKey(); 
String value = myPair.getValue();

This pair structure serves as a handy-dandy method to handle key-value data in Java, making your code clean like a shiny new Ferrari.

Off-the-Shelf Java KeyValuePair Options

You made once a Pair class. Now, meet some key-value pair options provided by Java that will spare you from reinventing the wheel.

Built-in convenience: java.util.AbstractMap.SimpleEntry

Check out AbstractMap.SimpleEntry. It's a ready-made class that does the key-value pair thing while you sit back and relax:

// Like buying furniture at IKEA instead of woodworking it yourself.
Map.Entry<Integer, String> entry = new AbstractMap.SimpleEntry<>(1, "One");

JavaFX's special guest: javafx.util.Pair

If you're building JavaFX applications, reach for javafx.util.Pair. It's designed for all your on-stage key-value needs:

// As smooth as a backstage pass at a concert.
javafx.util.Pair<Integer, String> javafxPair = new Pair<>(1, "One");

Unchangeable duo: Commons Lang ImmutablePair

For pairs that say, "we're never changing, ever," go with ImmutablePair from the house of Apache Commons Lang:

// Like a married old couple sitting in their favorite armchairs.
ImmutablePair<Integer, String> immutablePair = ImmutablePair.of(1, "One");

Head-spinning Pair choice? Here's how to pick.

Choose the right key-value pair option like you'd choose the right tool for a job (unless you're using a butter knife to unscrew stuff).

java.util.AbstractMap.SimpleEntry: the Janitor's choice

Pick AbstractMap.SimpleEntry when you need a quick-fix Map.Entry solution.
Use it if importing a kitchen-sink library just for pairs feels like overkill.

javafx.util.Pair: the Showstealer's choice

Go for javafx.util.Pair in a JavaFX application (since it's already in the house).
Consider it when you need an easy-to-use key-value matchmaker.

Commons Lang ImmutablePair: the Safety Inspector's choice

Choose ImmutablePair when change is a big no-no for your pairs.
Opt for it when the extra Apache Commons utilities make you feel like a kid in a candy store.

The Android exception

If you smell an Android adventure, consider android.util.Pair. It’s an exception to normal Java pair implementations best suited for the Android ecosystem:

// For when you and Java go on a double date with Android and Kotlin.
android.util.Pair<String, String> androidPair = new android.util.Pair<>("key", "value");

Craft Your Own KeyValuePair

Shock everyone with your custom KeyValue class. Equip it to implement Map.Entry<K, V> and join the playing field with the big boys:

// Snazzy suit, polished shoes, ready to hit the dance floor.
public class KeyValue<K, V> implements Map.Entry<K, V> {
    // ...
}

The benefit? Your KeyValue class can directly mingle with any code dose dealing with Map.Entry objects, making it the life of the party.

Mind the pitfalls

Some practical caveats to ensure you don't trip and fall:

Safety First: Use generics with your Pair or key-value class to avoid turning your development process into a wild goose chase.
Change is Good, Stability is Better: If a 'forever unchanged' policy is your thing, opt for something immutable like ImmutablePair.
Weight Watching: While Pair or KeyValuePair might be nice to have, assess whether vanilla data structures might make your performance worries lighter.