Sorting HashMap by Value in Java 8 in Ascending and Descending Order

Venkatesh NukalaMarch 5th, 2021Last Updated: March 3rd, 2021

0 1,182 4 minutes read

A quick guide to sort HashMap by value in java and new java 8 api in ascending or descending order.

1. Overview

In this tutorial, We will learn how to sort HashMap by value using java 8 API.

Most of the times, we do sort the hashmap based on the keys but not rather than its values. There are some scenarios for example HashMap stores the name as key and age as value. Now, we want to sort the customers based on the their value age.

Let us explore the techniques to do sort the values of hashmap in java 8.

2. Sort HashMap By Value Java 8 – Ascending Order

Below example is to sort the map on values using Stream.sort() and Entry.comparingByValue() methods.

Entry.comparingByValue() does sorting in the ascending order.

Java 8 example:

package com.javaprogramto.collections.hashmap;
 
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
 
public class SortHashMapByValues {
 
    public static void main(String[] args) {
 
        // creating HashMap
        Map<String, Integer> namesAges = new HashMap<>();
 
        // storing the values
        namesAges.put("Hari", 35);
        namesAges.put("Jhon", 30);
        namesAges.put("Jakey", 50);
        namesAges.put("kane", 45);
 
        Map<String, Integer> sortByValueMap = namesAges.entrySet().stream().sorted(Entry.comparingByValue())
                .collect(Collectors.toMap(entry -> entry.getKey(), entry -> entry.getValue(),
                        (entry1, entry2) -> entry2, LinkedHashMap::new));
 
        System.out.println("HashMap before sorting by value - " + namesAges);
        System.out.println("HashMap after sorting by value - " + sortByValueMap);
    }
 
}

Output:

HashMap before sorting by value - {Hari=35, Jakey=50, Jhon=30, kane=45}
HashMap after sorting by value - {Jhon=30, Hari=35, kane=45, Jakey=50}

From the output, you can observe that new map is sorted based on the customer ages.

If you do not understand this java 8 lambda and stream operations, do not worry. I will explain you step by step and breaking down into separate statements.

Read the written comments for each line in the code and this will help you out for better understanding.

Once you are clear, you can write the code in single line.

package com.javaprogramto.collections.hashmap;
 
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class SortHashMapByValues {
 
    public static void main(String[] args) {
 
        // creating HashMap
        Map<String, Integer> namesAges = new HashMap<>();
 
        // storing the values
        namesAges.put("Hari", 35);
        namesAges.put("Jhon", 30);
        namesAges.put("Jakey", 50);
        namesAges.put("kane", 45);
 
        // Step 1: Getting the entry set from map
        Set<Map.Entry<String, Integer>> entrySet = namesAges.entrySet();
 
        // Step 2: converting entry set to stream
        Stream<Entry<String, Integer>> stream = entrySet.stream();
 
        // Step 3: comparator to sort using values.
        Comparator<Map.Entry<String, Integer>> comparator = Entry.comparingByValue();
 
        // Step 4: sorting the stream using comparator created in above step.
        Stream<Entry<String, Integer>> sortedStream = stream.sorted(comparator);
 
        // Step 5: Getting the each key and value from entry object from above stream.
        // Finally, adding each entry to the LinkedHashMap.
        // LinkedHashMap is used to preserve the insertion order. If you do not collect
        // object into LinkedHashMap then final sorted map looks like same as the
        // original map before sorting.
        Collector<Entry<String, Integer>, ?, Map<String, Integer>> toMap = Collectors.toMap(entry -> entry.getKey(),
                entry -> entry.getValue(), (entry1, entry2) -> entry2, LinkedHashMap::new);
 
        // Step 6: Collecting the sorted stream into Map.
        Map<String, Integer> finalSortedByValueMap = sortedStream.collect(toMap);
 
        // printing
        System.out.println("HashMap before sorting by value - " + namesAges);
        System.out.println("HashMap after sorting by value - " + finalSortedByValueMap);
    }
}

This program also generates the output as same as above single line stream example.

Note:

When you divide the stream into multiple lines, JVM does not execute the code immediately after executing the each line. All stream operations are invoked if and if only the terminal operations are called such as collect(), max(), min() methods.

3. Sort HashMap By Value Java 8 – Descending Order

Next, Learn how to sort the HashMap by values in Descending order using
Collections.reverseOrder() method.

package com.javaprogramto.collections.hashmap;
 
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class SortHashMapByValues {
 
    public static void main(String[] args) {
 
        // creating HashMap
        Map<String, Integer> namesAges = new HashMap<>();
 
        // storing the values
        namesAges.put("Hari", 35);
        namesAges.put("Jhon", 30);
        namesAges.put("Jakey", 50);
        namesAges.put("kane", 45);
 
        Map<String, Integer> sortedMapInDescending = namesAges.entrySet()
            .stream()
            .sorted(Collections.reverseOrder(Entry.comparingByValue()))
            .collect(Collectors.toMap(entry -> entry.getKey(), entry -> entry.getValue(),
                    (entry1, entry2) -> entry2, LinkedHashMap::new));
         
        // printing
        System.out.println("HashMap before sorting by value - " + namesAges);
        System.out.println("HashMap after sorting by value in descending order- " + sortedMapInDescending);
    }
}

Output:

HashMap before sorting by value - {Hari=35, Jakey=50, Jhon=30, kane=45}
HashMap after sorting by value in descending order- {Jakey=50, kane=45, Hari=35, Jhon=30}

4. HashMap Sorting using Method Reference

Example program using java 8 method ref concept.

// sorting using method ref
// Descending
Map<String, Integer> sortedMapInDescendingOrder = namesAges.entrySet()
.stream()
.sorted(Collections.reverseOrder(Entry.comparingByValue()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
        (entry1, entry2) -> entry2, LinkedHashMap::new));
 
// Ascending
Map<String, Integer> sortedMapIAscendingOrder = namesAges.entrySet()
.stream()
.sorted(Collections.reverseOrder(Entry.comparingByValue()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
    (entry1, entry2) -> entry2, LinkedHashMap::new));