Home » Java » Core Java » Sorting HashMap by Value in Java 8 in Ascending and Descending Order

About Venkatesh Nukala

Venkatesh Nukala is a Software Engineer working for Online Payments Industry Leading company. In my free time, I would love to spend time with family and write articles on technical blogs. More on JavaProgramTo.com

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

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:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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:

1
2
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.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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:

1
2
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.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
// 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));

5. Conclusion

In this article, We have seen how to sort HashMap by Value in Java 8 in descending or ascending order.

And alos seen using Method Reference concept.

GitHub

How to convert HashMap to ArrayList in java 8?

Published on Java Code Geeks with permission by Venkatesh Nukala, partner at our JCG program. See the original article here: Sorting HashMap by Value in Java 8 in Ascending and Descending Order

Opinions expressed by Java Code Geeks contributors are their own.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

 

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

 

and many more ....

 

Receive Java & Developer job alerts in your Area

I have read and agree to the terms & conditions

 

Subscribe
Notify of
guest

This site uses Akismet to reduce spam. Learn how your comment data is processed.

0 Comments
Inline Feedbacks
View all comments