Java LinkedHashMap get first or last entry

java

prompt-engineering

performance

best-practices

byAnton Shumikhin·Jan 27, 2025

To quickly retrieve the first entry from a LinkedHashMap:

Map.Entry<Integer, String> firstEntry = map.entrySet().iterator().next();

To get the last entry in a traditional non-stream approach:

Map.Entry<Integer, String> lastEntry = null;
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    lastEntry = entry; // This may seem like a long jog, but it's not a marathon, trust me! ;) 
}

And for the modern Java 8+ folk, use streams to get the last entry in style:

Map.Entry<Integer, String> lastEntry = map.entrySet().stream().reduce((a, b) -> b).orElse(null); // No pressure, take a stroll through the stream!

External libraries to the rescue

In case the standard Java methods seem a bit tedious, external libraries can be your best friend providing efficient and cleaner ways:

The Apache Commons Collections is ever ready to help with its LinkedMap. The firstKey() and lastKey() methods save you some hustle when dealing with large LinkedHashMaps.
The Guava library from Good Guy Google introduces Iterables.getLast(). A simple yet powerful way to fetch the last element.

Reflection: a double-edged sword

In a world where accessing private members is a taboo, daring souls can resort to reflection. But at the same time, be wary of the potential future compatibility troubles:

Encapsulate the reflection logic within a method.
Always have a fallback ready in case the reflection trick fails.
Ensure precise logging of exceptions for aiding future troubleshooting sessions.

Mind the performance

While dealing with large data structures, remember, every operation counts:

Iterating over a LinkedHashMap can feel like trudging through a swamp.
The toArray() method brings a breath of fresh air but do mind the extra memory usage.
Stream-based approaches offer a balance between simplicity and performance.

Advanced Java techniques

Here are a couple of go-to groovy methods when dealing with specific requirements:

The NavigableMap protocol

Think of using Java's NavigableMap for a more robust interface when you frequently crave for first or last entries.

Null-proof your code

Prevent NullPointerException disasters when using reduce() methods in streams:

Map.Entry<Integer, String> lastEntry = map.entrySet().stream()
    .reduce((first, second) -> second)
    .orElseThrow(() -> new NoSuchElementException("Oops! Looks like the map ran out of entries."));

Good old utility methods

When repeating some tasks feels like déjà vu, utility methods are here to save the day:

public static <K, V> Map.Entry<K, V> getFirstEntry(LinkedHashMap<K, V> map) {
    return map.entrySet().iterator().next(); // A Map.Entry walks into a bar... 
}

public static <K, V> Map.Entry<K, V> getLastEntry(LinkedHashMap<K, V> map) {
    return map.entrySet().stream().reduce((a, b) -> b).orElse(null); // Who knew walking on the stream could be this fun? 
}