In this tutorial, I will show you how to order elements in a Map object using the Stream object and the Collectors object in Java by key and by value.
For example, we have a Map object like this:
|
1 2 3 4 |
Map<String, Integer> studentMap = new HashMap<>(); studentMap.put("Khanh", 31); studentMap.put("Thanh", 25); studentMap.put("Dung", 35); |
Prior to Java 8, to sort the elements of this Map object by key, we could use the Collections.sort() static method of the Collections class:
|
1 2 3 4 5 6 7 8 9 |
List<Map.Entry<String, Integer>> students = new ArrayList<Map.Entry<String, Integer>>(); students.addAll(studentMap.entrySet()); Collections.sort(students, new Comparator<Map.Entry<String, Integer>>() { @Override public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) { return o1.getKey().compareTo(o2.getKey()); } }); |
Result:
Do the same if you want to use the sort() static method of the Collections class to sort the elements in the Map object by value.
From Java 8 onwards, you have another way to use the Stream object with the Collectors object.
We will create a new Stream object from the Map object and then use the sorted() and collect() methods of this Stream object to sort.
For example, we need to order the elements of the Map object by key, we will code as follows:
|
1 2 3 4 |
Map<String, Integer> students = studentMap.entrySet() .stream() .sorted((o1, o2) -> o1.getKey().compareTo(o2.getKey())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new)); |
Here, the sorted() method acts as an intermediate operation in the Stream pipeline. The parameter of this method is a Comparator object that allows us to define what criteria to sort. You can also use the static comparingByKey() method of the Map.Entry class to sort by key as follows:
|
1 2 3 4 |
Map<String, Integer> students = studentMap.entrySet() .stream() .sorted(Map.Entry.comparingByKey()) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new)); |
The collect() method will act as a terminal operation in the Stream pipeline. The parameter of this method is a Collectors object and we will use the Collectors object’s toMap() method to construct a new Map object after sorting.
The Collectors object’s toMap() method has some overload methods:
|
1 |
toMap(Function keyMapper, Function valueMapper) |
|
1 |
toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) |
|
1 |
toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction, Supplier mapSupplier) |
Where the first and second parameters of the toMap() method are instances of the Function interface used to generate keys and values for the new Map object.
The third parameter of the toMap() method is an optional parameter that is used in case the key of the new Map object has duplicate values. Using the BinaryOperator object, we can select the value of these duplicate keys, avoiding the IllegalStateException. In the above example, (oldValue, newValue) -> oldValue means that in case the key is duplicated, we will get the value of the previous key.
The final parameter of the toMap() method is also an optional parameter, which allows us to define a new Map object as a class instance. By default, if you do not use this parameter, then the class will be HashMap.
The result of this example is as follows:
To order elements in a Map object by value, we can use the static comparingByValue() method of the Map.Entry object:
|
1 2 3 4 |
Map<String, Integer> students = studentMap.entrySet() .stream() .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new)); |
Here, I use the reverseOrder() static method of the Comparator class to sort these values descending.
Result:
