Does Java SE 8 have Pairs or Tuples?

java

streaming

functional-programming

java-8

byAlex Kataev·Feb 5, 2025

In Java SE 8, there's no in-built pair or tuple support, but you can simulate pairs using AbstractMap.SimpleEntry:

Map.Entry<String, Integer> pair = new AbstractMap.SimpleEntry<>("apple", 10);

You can extract elements with pair.getKey() and pair.getValue(). For more complex tuples, consider third-party libraries or create a custom tuple class.

JavaFX Pair — a Decent Alternative

When your project already relies on JavaFX, you can make use of javafx.util.Pair:

Pair<Integer, String> pair = new Pair<>(1, "apple");

Caution: though it's convenient, loading JavaFX just for pairs may overweight your project.

Rescuing with AbstractMap

You can use AbstractMap.SimpleEntry and SimpleImmutableEntry as a kind of "Java 8 pair":

Map.Entry<Integer, String> mutablePair = new AbstractMap.SimpleEntry<>(1, "apple");
Map.Entry<Integer, String> immutablePair = new AbstractMap.SimpleImmutableEntry<>(1, "apple");

These are part of Java SE and can be handy for storing key-value data.

Stream Techniques for Arrays

Iterative Indexes

For looping over indexes in arrays, utilize IntStream.range:

IntStream.range(0, array.length)
         .forEach(index -> {
             // process array[index], calculations so fun, they're almost "index"plicable 😉
         });

Streams and lambda functions can minimize complex loops into concise, efficient lines.

Collection Made Efficient

Efficiently gather your stream results using toList():

List<String> getList = Stream.of("apple", "banana", "cherry")
                             .collect(Collectors.toList());

Streamlining data gathering from streams improves readability and hassle-free decoding.

Advanced Capabilities

Embracing Map.entry in Java 9

Map.entry in Java 9 offers a straightforward pattern for creating pairs, null-safe and conscise:

Map.Entry<String, Integer> entry = Map.entry("apple", 10);

Reducing boilerplate code while dealing with pairs. Null's better!

Java 14’s Record Dazzle

From JDK 14 onwards, record classes present a brand-new lookout for defining tuples:

record Pair<K, V>(K key, V value) { }

Pair<String, Integer> pair = new Pair<>("apple", 10);

Records are a boon for creating typesafe, immutable tuples.

Libraries and Techniques

Apache Common Lang’s Tuple Glory

Apache Commons Lang library, your haven for tuples:

Pair<String, Integer> pair = Pair.of("apple", 10);
Triple<String, Integer, Double> triple = Triple.of("apple", 10, 15.0);

These classes furnish an instantaneous solution through a simplified API.

Mastering Functional Programming

With Java SE 8, bring functional programming to the fore:

list.stream()
    .filter(s -> s.contains("a"))
    .forEach(System.out::println);

Employ lambda functions and steams to enhance your code expressiveness.

Further Techniques for Nuanced Coding

Tapping into Parallel Streams

Parallel streams can be employed for computations on large datasets:

array.parallelStream()
     .filter(...)
     .forEach(...);

Be sure to test for performance gain as parallel streams might not always be faster due to overhead.

Custom Classes for Tuples

When need arises for tuples beyond pairs, consider creating a custom composite class:

public class Trio<K, V, T> {
    public K first;
    public V second;
    public T third;

    public Trio(K first, V second, T third) {
        this.first = first;
        this.second = second;
        this.third = third;
    }
    // Trio gets the party started! 🥳
    // Getters and setters ...
}