Java 8 – Sort a Map by Key

Introduction

Sorting a map by its keys is a common task in Java, especially when you need to organize data in a specific order for display, logging, or processing. While the Map interface does not inherently maintain any order, Java provides several ways to sort a map by its keys. Java 8 introduced the Stream API, which offers a concise and powerful approach to sorting maps. In this guide, we’ll explore how to sort a map by its keys using different methods in Java 8, including natural ordering and custom comparator logic.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Sorting a Map by Key Using TreeMap
  • Sorting a Map by Key Using Streams
  • Sorting a Map by Key with a Custom Comparator
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Accepts a map of key-value pairs.
• Sorts the map by its keys.
• Outputs the sorted map.

Example 1:

• Input: Map {3: "Banana", 1: "Apple", 2: "Orange"}
• Output: Sorted Map {1: "Apple", 2: "Orange", 3: "Banana"}

Example 2:

• Input: Map {"Banana": 3, "Apple": 1, "Orange": 2}
• Output: Sorted Map {"Apple": 1, "Banana": 3, "Orange": 2}

Solution Steps

1. Create a Map: Start with an unsorted map of key-value pairs.
2. Sort the Map by Key: Use one of the methods available in Java 8 to sort the map by its keys.
3. Display the Result: Print the sorted map.

Java Program

Sorting a Map by Key Using TreeMap

The simplest way to sort a map by its keys is to use a TreeMap, which automatically sorts its entries by their natural key order.

import java.util.Map;
import java.util.TreeMap;

/**
 * Java 8 - Sort a Map by Key Using TreeMap
 * Author: https://www.rameshfadatare.com/
 */
public class SortMapByKeyUsingTreeMap {

    public static void main(String[] args) {
        // Step 1: Create an unsorted map
        Map<Integer, String> unsortedMap = Map.of(
            3, "Banana",
            1, "Apple",
            2, "Orange"
        );

        // Step 2: Create a TreeMap to sort the map by keys
        Map<Integer, String> sortedMap = new TreeMap<>(unsortedMap);

        // Step 3: Display the result
        System.out.println("Sorted Map: " + sortedMap);
    }
}

Output

Sorted Map: {1=Apple, 2=Orange, 3=Banana}

Explanation

• The TreeMap class automatically sorts the map by its keys in their natural order (ascending for numbers, lexicographical for strings).
• The original unsorted map is passed to the TreeMap constructor, which sorts it by keys.

Sorting a Map by Key Using Streams

Using the Stream API, you can sort the entries of a map by their keys and then collect the results into a new, sorted map.

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Java 8 - Sort a Map by Key Using Streams
 * Author: https://www.rameshfadatare.com/
 */
public class SortMapByKeyUsingStreams {

    public static void main(String[] args) {
        // Step 1: Create an unsorted map
        Map<String, Integer> unsortedMap = Map.of(
            "Banana", 3,
            "Apple", 1,
            "Orange", 2
        );

        // Step 2: Sort the map by keys using streams
        Map<String, Integer> sortedMap = unsortedMap.entrySet()
            .stream()
            .sorted(Map.Entry.comparingByKey())
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                (oldValue, newValue) -> oldValue,
                LinkedHashMap::new
            ));

        // Step 3: Display the result
        System.out.println("Sorted Map: " + sortedMap);
    }
}

Output

Sorted Map: {Apple=1, Banana=3, Orange=2}

Explanation

• The entrySet() method is used to convert the map to a set of key-value pairs.
• The stream() method creates a stream from these entries.
• The sorted(Map.Entry.comparingByKey()) method sorts the stream by the keys.
• The collect(Collectors.toMap(...)) method collects the sorted entries back into a map, maintaining the order with a LinkedHashMap.

Sorting a Map by Key with a Custom Comparator

You can also sort a map by its keys using a custom comparator, allowing you to define a specific order (e.g., descending order).

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Java 8 - Sort a Map by Key with a Custom Comparator
 * Author: https://www.rameshfadatare.com/
 */
public class SortMapByKeyWithCustomComparator {

    public static void main(String[] args) {
        // Step 1: Create an unsorted map
        Map<Integer, String> unsortedMap = Map.of(
            3, "Banana",
            1, "Apple",
            2, "Orange"
        );

        // Step 2: Sort the map by keys in descending order using a custom comparator
        Map<Integer, String> sortedMap = unsortedMap.entrySet()
            .stream()
            .sorted(Map.Entry.<Integer, String>comparingByKey().reversed())
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                (oldValue, newValue) -> oldValue,
                LinkedHashMap::new
            ));

        // Step 3: Display the result
        System.out.println("Sorted Map: " + sortedMap);
    }
}

Output

Sorted Map: {3=Banana, 2=Orange, 1=Apple}

Explanation

• The sorted(Map.Entry.comparingByKey().reversed()) method sorts the stream by the keys in descending order.
• The sorted entries are collected back into a LinkedHashMap to maintain the order.

Advanced Considerations

• Null Keys: If your map contains null keys, be cautious with sorting as TreeMap does not allow null keys and will throw a NullPointerException. Handle nulls explicitly if needed.

• Performance Considerations: Sorting a map using streams is generally efficient, but for very large maps, test the performance, especially if the custom comparator logic is complex.

• Order Preservation: If you need to maintain the sorted order after operations, always use LinkedHashMap when collecting the results, as it preserves insertion order.

Conclusion

This guide provides methods for sorting a map by its keys in Java 8, covering approaches with TreeMap, the Stream API, and custom comparators. Sorting maps is a common requirement in many applications, and Java 8 provides powerful tools to perform this task efficiently and flexibly. Depending on your specific use case, you can choose the method that best fits your needs for sorting maps in Java.