How to Sort a Java Map by Values: 3 Effective Methods Explained

Introduction

Java Map structures like HashMap store data in key-value pairs but don’t guarantee order. Sorting a Map by its values is a common challenge, especially when dealing with datasets like scores, rankings, or word frequencies. In this guide, we’ll explore three efficient methods to sort a Map by values, including modern Java 8+ techniques and external libraries like Guava.

Why Sorting a Map by Values is Tricky

Maps prioritize fast lookups via keys, not ordered values. Direct sorting isn’t supported, so developers must:

1. Extract entries into a sortable structure.
2. Sort using a custom comparator.
3. Preserve order in a new Map (e.g., LinkedHashMap).

Method 1: Java 8 Streams (Recommended)

Java 8’s Stream API simplifies sorting with minimal code. Here’s how:

Ascending Order

Map<String, Integer> sortedMap = originalMap.entrySet()  
    .stream()  
    .sorted(Map.Entry.comparingByValue())  
    .collect(Collectors.toMap(  
        Map.Entry::getKey,  
        Map.Entry::getValue,  
        (e1, e2) -> e1, // Handle key collisions  
        LinkedHashMap::new // Preserve order  
    ));  

Descending Order

Map<String, Integer> sortedMap = originalMap.entrySet()  
    .stream()  
    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))  
    .collect(Collectors.toMap(  
        Map.Entry::getKey,  
        Map.Entry::getValue,  
        (e1, e2) -> e1,  
        LinkedHashMap::new  
    ));  

Pros:

• Clean, functional syntax.
• Handles duplicate values.
• No external libraries needed.

Cons:

• Requires Java 8+.

Method 2: TreeMap with Custom Comparator

TreeMap sorts entries by keys by default. To sort by values, use a custom comparator:

Comparator<String> valueComparator = new Comparator<>() {  
    public int compare(String k1, String k2) {  
        int valueCompare = originalMap.get(k1).compareTo(originalMap.get(k2));  
        return valueCompare == 0 ? k1.compareTo(k2) : valueCompare; // Handle ties  
    }  
};  

Map<String, Integer> sortedMap = new TreeMap<>(valueComparator);  
sortedMap.putAll(originalMap);  

Pros:

• Automatically maintains sorted order.

Cons:

• Dangerous if values change after insertion (the comparator uses the original values).
• Inconsistent with Map contract if comparator ignores keys.

Method 3: Google Guava (Legacy Approach)

For older Java versions, Guava’s Ordering class offers flexibility:

Ordering<String> valueOrdering = Ordering.natural()  
    .onResultOf(Functions.forMap(originalMap))  
    .compound(Ordering.natural()); // Break ties with keys  

ImmutableSortedMap<String, Integer> sortedMap = ImmutableSortedMap.copyOf(  
    originalMap,  
    valueOrdering  
);  

Pros:

• Elegant handling of duplicate values.
• Immutable result.

Cons:

• Requires Guava dependency.

Common Pitfalls & Solutions

1. Duplicate Values:
   • Use keys as tiebreakers in comparators.
2. Changing Values:
   • Avoid TreeMap if values might change. Use streams for dynamic sorting.
3. Performance:
   • For large datasets, prefer LinkedHashMap over repeated TreeMap insertions.

Best Practices

• Use Java 8 Streams for modern, concise code.
• Prefer Immutability with ImmutableSortedMap (Guava) or Collections.unmodifiableMap().
• Document Comparators to clarify sorting logic.

Comparison Table

Conclusion

Sorting a Map by values is essential for tasks like leaderboards or analytics. While Java 8 streams offer the most robust solution, TreeMap and Guava provide alternatives for legacy systems. Always validate your comparator logic and avoid side effects in mutable Maps.

Keywords:

• Sort Java Map by value
• TreeMap sort by value
• Java 8 stream sort Map
• Guava Ordering Map
• LinkedHashMap sorted by value
• Comparator for Map values

Level Up Your Java Skills!
Try these methods in your next project and share your experience in the comments below. 👨💻🚀