How to Sort HashMap by Value

In Java, sorting HashMap by values is complicated because there is no direct method available. If we need to sort the HashMap by values, we should create a Comparator. It compares two elements based on the values.

After that get the Set of elements from the Map and convert Set into the List. Use the Collections.sort(List) method to sort the list of elements by values by passing customized comparator. Now create a new LinkedHashMap and copy the sorted elements into that. Since LinkedHashMap guarantees the insertion order of mappings. We get a HashMap whose values are in sorted order.

Java Collections.sort() method

Java collections class provides a method to sort all list implementations such as LinkedList and ArrayList. There are two overloaded sort methods():

sort(List list): It sorts the elements of the List in ascending order of their natural order.
sort(List list, Comparator <T>): It sorts the elements of the list according to the order included by the comparator.

Syntax

The method does not return any value. It throws the following exceptions:

ClassCastException: If the list contains elements that are not mutually comparable.

UnsupportedOperationException: If the specified list's list-iterator does not support the set operation.

The difference between sorting HashMap by Keys and Values is that it can have duplicate values but not duplicate Keys. We cannot use TreeMap to sort values because TreeMap sorts elements by Keys.

Example of sort HashMap by Value

In the following example, we have sorted the map in ascending and descending order.

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SortByValue 
{
//implementation of HashMap
Map<String, Integer> map = new HashMap<String, Integer>();
public static void main(String[] args) 
{	
SortByValue sv = new SortByValue();
sv.createMap();
System.out.println("Sorting values in ascending order:");
sv.sortByValue(true);
System.out.println("Sorting values in  descending order");
sv.sortByValue(false);
}
//method to add elements in the HashMap
void createMap() 
{
map.put("Apple", 65000);
map.put("HP", 20000);
map.put("Dell", 32000);
map.put("Asus", 21478);
map.put("Samsung", 36546);
map.put("Lenovo", 19990);
System.out.println("Before sorting: ");
printMap(map);
}
//sort elements by values
void sortByValue(boolean order) 
{
//convert HashMap into List	
List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(map.entrySet());
//sorting the list elements
Collections.sort(list, new Comparator<Entry<String, Integer>>() 
{
public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) 
{
if (order) 
{
//compare two object and return an integer
return o1.getValue().compareTo(o2.getValue());} 
else 
{
return o2.getValue().compareTo(o1.getValue());
}
}
});
//prints the sorted HashMap
Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
for (Entry<String, Integer> entry : list) 
{
sortedMap.put(entry.getKey(), entry.getValue());
}
printMap(sortedMap);
}
//method for printing the elements
public void printMap(Map<String, Integer> map) 
{
System.out.println("Company\t Price	");
for (Entry<String, Integer> entry : map.entrySet()) 
{
System.out.println(entry.getKey() +"\t"+entry.getValue());
}
System.out.println("\n");
}
}

Output:

Before sorting: 
Company	 Price	
Dell		32000
HP		20000
Lenovo	19990
Samsung	36546
Apple		65000
Asus		21478


Sorting values in ascending order:
Company	 Price	
Lenovo	19990
HP		20000
Asus		21478
Dell		32000
Samsung	36546
MAC Book	65000


Sorting values in descending order:
Company	 Price	
MAC Book	65000
Samsung	36546
Dell		32000
Asus		21478
HP		20000
Lenovo	19990

Next TopicJava Tutorial

← prev next →