In the tutorial, we show how to sort Java Map by Values, by Keys, and Custom Objects with Descending & Ascending order in Java 8.
Contents
I. How to Sort Map by Values?
– We use .stream().sorted(Map.Entry.comparingByValue()) to sort map by value:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
package com.grokonez.sortjavamap; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.stream.Collectors; public class SortJavaMap { public static void main(String[] args) { final Map<String, Integer> numMap = new HashMap<>(); numMap.put("ten", 10); numMap.put("eight", 8); numMap.put("one", 1); numMap.put("three", 3); numMap.put("five", 5); Map<String, Integer> sortedByValues = numMap.entrySet() .stream() .sorted(Map.Entry.comparingByValue()) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)); System.out.println(numMap); // -> {one=1, ten=10, three=3, five=5, eight=8} System.out.println(sortedByValues); // -> {one=1, three=3, five=5, eight=8, ten=10} } } |
– Note: using a LinkedHashMap to collect results. Because, by default Collectors.toMap returns a new HashMap, but HashMap doesn’t guarantee iteration order, while LinkedHashMap does.
Reversed Order
How to reverse order?
-> We use comparingByValue().reversed().
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
package com.grokonez.sortjavamap; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.stream.Collectors; public class SortJavaMap { public static void main(String[] args) { final Map<String, Integer> numMap = new HashMap<>(); numMap.put("ten", 10); numMap.put("eight", 8); numMap.put("one", 1); numMap.put("three", 3); numMap.put("five", 5); final Map<String, Integer> sortedByValues = numMap.entrySet() .stream() .sorted((Map.Entry.<String, Integer>comparingByValue().reversed())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)); System.out.println(numMap); // -> {one=1, ten=10, three=3, five=5, eight=8} System.out.println(sortedByValues); // -> {ten=10, eight=8, five=5, three=3, one=1} } } |
II. How to Sort Java Map by Keys?
– We do the same above ways but using .sorted((Map.Entry.comparingByKey())):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
package com.grokonez.sortjavamap; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.stream.Collectors; public class SortJavaMap { public static void main(String[] args) { final Map<String, Integer> numMap = new HashMap<>(); numMap.put("t", 10); numMap.put("e", 8); numMap.put("o", 1); numMap.put("t", 3); numMap.put("f", 5); System.out.println(numMap); // -> {t=3, e=8, f=5, o=1} Map<String, Integer> sortedByValues = numMap.entrySet() .stream() .sorted(Map.Entry.comparingByKey()) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)); System.out.println(sortedByValues); // -> {e=8, f=5, o=1, t=3} } } |
Reversed Order
– For reversed order, we use .sorted((Map.Entry.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
package com.grokonez.sortjavamap; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.stream.Collectors; public class SortJavaMap { public static void main(String[] args) { final Map<String, Integer> numMap = new HashMap<>(); numMap.put("t", 10); numMap.put("e", 8); numMap.put("o", 1); numMap.put("t", 3); numMap.put("f", 5); System.out.println(numMap); // -> {t=3, e=8, f=5, o=1} Map<String, Integer> sortedByValues = numMap.entrySet() .stream() .sorted((Map.Entry.<String, Integer>comparingByKey().reversed())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)); System.out.println(sortedByValues); // -> {t=3, o=1, f=5, e=8} } } |
III. Sort Map Custom Objects by CompareTo function
– To sort a Map with Custom Objects, we use compareTo function:
|
1 2 3 4 5 6 7 8 9 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 |
package com.grokonez.sortjavamap; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.stream.Collectors; class Customer implements Comparable<Object>{ String name; Integer salary; Customer(String name, int salary){ this.name = name; this.salary =salary; // USD } @Override public int compareTo(Object o) { Customer e = (Customer) o; return e.salary.compareTo(salary); } public String toString() { return "[name=" + name + ", salary=" + salary + "]"; } } public class SortJavaMap { public static void main(String[] args) { final Map<String, Customer> customerMap = new HashMap<>(); customerMap.put("George", new Customer("Jack", 2100)); customerMap.put("Oliver",new Customer("Jack", 5200)); customerMap.put("Jack", new Customer("Jack", 4000)); customerMap.put("Charlie", new Customer("Jack", 4500)); customerMap.put("Harry", new Customer("Jack", 5600)); final Map<String, Customer> sortedByValues = customerMap.entrySet() .stream() .sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)); System.out.println(customerMap); // -> {George=[name=Jack, salary=2100], Harry=[name=Jack, salary=5600], Oliver=[name=Jack, salary=5200], Charlie=[name=Jack, salary=4500], Jack=[name=Jack, salary=4000]} System.out.println(sortedByValues); // -> {George=[name=Jack, salary=2100], Jack=[name=Jack, salary=4000], Charlie=[name=Jack, salary=4500], Oliver=[name=Jack, salary=5200], Harry=[name=Jack, salary=5600]} } } |
Reversed Order
– For descending order, we re-define the compareTo function in Customer class:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class Customer implements Comparable<Object>{ String name; Integer salary; ... @Override public int compareTo(Object o) { Customer e = (Customer) o; return salary.compareTo(e.salary); } ... } |
-> Full Example:
|
1 2 3 4 5 6 7 8 9 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 |
package com.grokonez.sortjavamap; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.stream.Collectors; class Customer implements Comparable<Object>{ String name; Integer salary; Customer(String name, int salary){ this.name = name; this.salary =salary; // USD } @Override public int compareTo(Object o) { Customer e = (Customer) o; return salary.compareTo(e.salary); } public String toString() { return "[name=" + name + ", salary=" + salary + "]"; } } public class SortJavaMap { public static void main(String[] args) { final Map<String, Customer> customerMap = new HashMap<>(); customerMap.put("George", new Customer("Jack", 2100)); customerMap.put("Oliver",new Customer("Jack", 5200)); customerMap.put("Jack", new Customer("Jack", 4000)); customerMap.put("Charlie", new Customer("Jack", 4500)); customerMap.put("Harry", new Customer("Jack", 5600)); final Map<String, Customer> sortedByValues = customerMap.entrySet() .stream() .sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)); System.out.println(customerMap); // -> {George=[name=Jack, salary=2100], Harry=[name=Jack, salary=5600], Oliver=[name=Jack, salary=5200], Charlie=[name=Jack, salary=4500], Jack=[name=Jack, salary=4000]} System.out.println(sortedByValues); // -> {Harry=[name=Jack, salary=5600], Oliver=[name=Jack, salary=5200], Charlie=[name=Jack, salary=4500], Jack=[name=Jack, salary=4000], George=[name=Jack, salary=2100]} } } |