Sort Map in Java by reverse ordering of its keys

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

1. Using `TreeMap`

TreeMap is a Red-Black tree-based implementation of Map, which is sorted according to the comparator provided to its constructor. By passing any Reverse Order Comparator to the TreeMap, we can sort the map according to the reverse ordering of its keys.

import java.util.Comparator;

import java.util.HashMap;

import java.util.Map;

import java.util.TreeMap;

class Main

{

// Generic method to sort map in Java by the reverse ordering of its keys

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

{

Map<K, V> treeMap = new TreeMap<>(new Comparator<K>() {

@Override

public int compare(K a, K b) {

return b.compareTo(a);

}

});

treeMap.putAll(map);

return treeMap;

}

public static void main(String[] args)

{

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

colors.put("RED", "#FF0000");

colors.put("BLUE", "#0000FF");

colors.put("GREEN", "#008000");

colors.put("YELLOW", "#FFFF00");

colors = sortByKeys(colors);

System.out.println("Sorted map by keys in Reverse Order:\n" + colors);

}

Download Run Code

Output:

Sorted map by keys in Reverse Order :
{YELLOW=#FFFF00, RED=#FF0000, GREEN=#008000, BLUE=#0000FF}

The above code uses a custom comparator, but we can use reverse order comparators provided by Java such as:

1	Map<K, V> treeMap = new TreeMap<>(Collections.reverseOrder());

1	Map<K, V> treeMap = new TreeMap<>((a, b) -> b.compareTo(a));

⮚ TreeMap.descendingMap() method

We can use TreeMap.descendingMap() that returns a reverse order view of the mappings contained in the treemap.

// Generic method to sort map by keys in reverse order

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

{

// construct a `TreeMap` from the given map and return a reverse order

// view of the mappings contained in this map

return new TreeMap<>(unsortedMap).descendingMap();

}

Download Run Code

⮚ Using Guava’s TreeMap

We can also use the TreeMap implementation provided by Guava, as shown below:

// Generic method to sort map in Java by the reverse ordering of its keys

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

TreeMap<K, V> treeMap = Maps.newTreeMap(

(Comparator<K>) Ordering.natural().reverse());

treeMap.putAll(map);

return treeMap;

}

Download Run Code

2. Using `LinkedHashMap`

We know that the LinkedHashMap iteration order is the same as the insertion order of keys into the map. We can use this property to produce a copy of a map that is sorted according to the reverse ordering of its keys.

The idea is to create a list of keys from the map and sort it in descending order. Then for every key in the reverse sorted list, we insert a key-value pair into an empty LinkedHashMap. The resultant LinkedHashMap will be sorted according to the reverse ordering of its keys.

import java.util.*;

class Main

{

// Generic method to sort map in Java by the reverse ordering of its keys

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<K>(map.keySet());

Collections.sort(keys, Collections.reverseOrder());

// create an empty `LinkedHashMap`

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

// use `ListIterator` to iterate list

ListIterator<K> itr = keys.listIterator();

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

// in `LinkedHashMap`

while (itr.hasNext())

{

K key = itr.next();

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

}

return linkedHashMap;

}

public static void main(String[] args)

{

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

colors.put("RED", "#FF0000");

colors.put("BLUE", "#0000FF");

colors.put("GREEN", "#008000");

colors.put("YELLOW", "#FFFF00");

colors = sortByKeys(colors);

System.out.println("Sorted map by keys in Reverse Order:\n" + colors);

}

Download Run Code

Output:

Sorted map by keys in Reverse Order :
{YELLOW=#FFFF00, RED=#FF0000, GREEN=#008000, BLUE=#0000FF}

3. Using Java 8

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

Obtain stream from the set view of the mappings contained in the map.
Sort the stream in reverse order of keys using Stream.sorted() method.
Construct a LinkedHashMap from the stream using Stream.collect() with Collectors.toMap().

The following program demonstrates it:

import java.util.Collections;

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> colors = new HashMap<>();

colors.put("RED", "#FF0000");

colors.put("BLUE", "#0000FF");

colors.put("GREEN", "#008000");

colors.put("YELLOW", "#FFFF00");

// Sort map in Java 8 and above by reverse ordering of its keys

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

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

.sorted(Collections.reverseOrder(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" + colors);

}

Download Run Code

Output:

Sorted map by keys in Reverse Order :
{YELLOW=#FFFF00, RED=#FF0000, GREEN=#008000, BLUE=#0000FF}

Another approach that doesn’t involve using a collector is to use the Stream.forEachOrdered() method on the reverse sorted stream that inserts each element of the stream into a new LinkedHashMap.

import java.util.Collections;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

class Main

{

public static void main(String[] args)

{

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

colors.put("RED", "#FF0000");

colors.put("BLUE", "#0000FF");

colors.put("GREEN", "#008000");

colors.put("YELLOW", "#FFFF00");

// Sort map in Java 8 and above by reverse ordering of its keys

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

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

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

.sorted(Collections.reverseOrder(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 in Reverse Order :
{YELLOW=#FFFF00, RED=#FF0000, GREEN=#008000, BLUE=#0000FF}

That’s all about sorting Map in Java by the reverse ordering of its keys.

References:

1. TreeMap Javadoc – Java SE 8

2. LinkedHashMap Javadoc – Java SE 8 Javadoc

Sort Map in Java by reverse ordering of its keys

1. Using TreeMap

2. Using LinkedHashMap

3. Using Java 8

Share this:

1. Using `TreeMap`

2. Using `LinkedHashMap`