Sort Map by keys in Java

This post will discuss various methods to sort map in Java according to the natural ordering of its keys.

1. Using `TreeMap`

TreeMap is a Red-Black tree-based implementation of Map, which is sorted according to its keys’ natural ordering. We can pass an unsorted map to the TreeMap constructor, which will then construct a new tree map containing the same mappings as the given map but ordered according to its keys’ natural ordering.

import java.util.HashMap;

import java.util.Map;

import java.util.TreeMap;

class Main

{

// Generic method to sort map by keys using `TreeMap`

public static <K, V> Map<K, V> sortByKeys(Map<K, V> unsortedMap)

{

// construct a `TreeMap` from the given map and return it

return new TreeMap<>(unsortedMap);

}

public static void main(String[] args)

{

Map<String, String> country = new HashMap<>();

country.put("India", "New Delhi");

country.put("USA", "Washington D.C.");

country.put("Japan", "Tokyo");

country.put("China", "Beijing");

country = sortByKeys(country);

System.out.println("Sorted map by keys :\n" + country);

}

Download Run Code

Output:

Sorted map by keys :
{China=Beijing, India=New Delhi, Japan=Tokyo, USA=Washington D.C.}

Using Guava’s TreeMap:

Google’s Guava library also provides TreeMap implementation, which we can use to create a mutable, empty TreeMap instance, which is sorted according to a Comparator provided at map creation time. We can pass Guava’s Ordering.natural() for the natural ordering of keys.

// Generic method to sort map by keys in Java using Guava

public static <K, V> TreeMap<K, V> sortByKeys(Map<K, V> unsortedMap) {

TreeMap<K, V> treeMap = Maps.newTreeMap((Comparator<K>) Ordering.natural());

treeMap.putAll(unsortedMap);

return treeMap;

}

Download Code

2. Using `LinkedHashMap`

LinkedHashMap is a hash table and linked list implementation of the Map interface, with predictable iteration order, which is the order in which keys were inserted into the map. We can use this property to produce a copy of a map that is sorted according to the natural ordering of its keys.

The idea is to create a list of keys present on the map and sort it. Then, we insert a key-value pair in an empty LinkedHashMap for every key in the sorted list. Keys will sort the resultant LinkedHashMap.

import java.util.*;

class Main

{

// Generic method to sort map by keys using `LinkedHashMap`

public static <K extends Comparable, V> Map<K, V> sortByKeys(Map<K, V> map)

{

// create a list of map keys and sort it

List<K> keys = new ArrayList(map.keySet());

Collections.sort(keys);

// create an empty insertion-ordered `LinkedHashMap`

Map<K, V> linkedHashMap = new LinkedHashMap<>();

// for every key in the sorted list, insert key-value

// pair in `LinkedHashMap`

for (K key: keys) {

linkedHashMap.put(key, map.get(key));

}

return linkedHashMap;

}

public static void main(String[] args)

{

Map<String, String> country = new HashMap<>();

country.put("India", "New Delhi");

country.put("USA", "Washington D.C.");

country.put("Japan", "Tokyo");

country.put("China", "Beijing");

country = sortByKeys(country);

System.out.println("Sorted map by keys :\n" + country);

}

Download Run Code

Output:

Sorted map by keys :
{China=Beijing, India=New Delhi, Japan=Tokyo, USA=Washington D.C.}

Here’s an equivalent version using the Stream API.

import java.util.*;

import java.util.stream.Collectors;

class Main

{

// Generic method to sort map by keys using `LinkedHashMap`

public static <K extends Comparable, V> Map<K, V> sortByKeys(Map<K, V> map)

{

// create a list of map keys and sort it

List<K> keys = new ArrayList(map.keySet());

Collections.sort(keys);

// for every key in the sorted list, insert key-value pair in an

// insertion-ordered `LinkedHashMap`

return keys.stream().collect(Collectors.toMap(key -> key, map::get,

(a, b) -> b, LinkedHashMap::new));

}

public static void main(String[] args)

{

Map<String, String> country = new HashMap<>();

country.put("India", "New Delhi");

country.put("USA", "Washington D.C.");

country.put("Japan", "Tokyo");

country.put("China", "Beijing");

country = sortByKeys(country);

System.out.println("Sorted map by keys :\n" + country);

}

Download Run Code

Output:

Sorted map by keys :
{China=Beijing, India=New Delhi, Japan=Tokyo, USA=Washington D.C.}

3. Using Java 8

We can also use Java 8 Stream to sort map by keys. Following are the steps:

Obtain stream from the set view of the mappings contained in the map.
Sort the stream in natural order of keys using Stream.sorted() method by passing comparator returned by Map.Entry.comparingByKey().
Collect all sorted elements in a LinkedHashMap using Stream.collect() with Collectors.toMap().

Please note that a stream is a sequence of items, not a sequence of key/value pairs. So, we can’t construct a map out of a stream without specifying how to extract keys and values from it. Java 8 provides Collectors.toMap() method for this purpose. We need to use an overloaded version of toMap() that returns LinkedHashMap instead of HashMap to retain the sorted order.

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.stream.Collectors;

class Main

{

public static void main(String[] args)

{

Map<String, String> country = new HashMap<>();

country.put("India", "New Delhi");

country.put("USA", "Washington D.C.");

country.put("Japan", "Tokyo");

country.put("China", "Beijing");

// Sort map by keys in Java 8 and above

country = country.entrySet() // Set<Entry<String, String>>

.stream() // Stream<Entry<String, String>>

.sorted(Map.Entry.comparingByKey())

.collect(Collectors.toMap(

Map.Entry::getKey,

Map.Entry::getValue,

(oldValue, newValue) -> oldValue,

LinkedHashMap::new));

System.out.println("Sorted map by keys :\n" + country);

}

Download Run Code

Output:

Sorted map by keys :
{China=Beijing, India=New Delhi, Japan=Tokyo, USA=Washington D.C.}

Following is another approach that doesn’t involve using a collector. It uses the Stream.forEachOrdered() method on the sorted stream that inserts each element of the stream into a new LinkedHashMap.

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

class Main

{

public static void main(String[] args)

{

Map<String, String> country = new HashMap<>();

country.put("India", "New Delhi");

country.put("USA", "Washington D.C.");

country.put("Japan", "Tokyo");

country.put("China", "Beijing");

// Sort map by keys in Java 8 and above

Map<String, String> sortedMap = new LinkedHashMap<>();

country.entrySet() // Set<Entry<String, String>>

.stream() // Stream<Entry<String, String>>

.sorted(Map.Entry.comparingByKey())

.forEachOrdered(entry ->

sortedMap.put(entry.getKey(), entry.getValue()));

System.out.println("Sorted map by keys :\n" + sortedMap);

}

Download Run Code

Output:

Sorted map by keys :
{China=Beijing, India=New Delhi, Japan=Tokyo, USA=Washington D.C.}

That’s all about sorting Map by keys in Java.

Related Post:

Sort Map by values in Java

References:

1. TreeMap Javadoc – Java SE 8
2. LinkedHashMap Javadoc – Java SE 8 Javadoc

1. Using TreeMap

2. Using LinkedHashMap

3. Using Java 8

Share this:

1. Using `TreeMap`

2. Using `LinkedHashMap`