How To Assort A Map Past Times Keys Inward Coffee Viii - Illustration Tutorial

In the final article, I receive got shown yous how to sort a Map past times values inwards Java 8 together with inwards this tutorial, yous volition larn how to sort a Map past times keys e.g. an HashMap, ConcurrentHashMap, LinkedHashmap, or fifty-fifty Hashtable. Theoretically, yous cannot sort a Map because it doesn't render whatsoever ordering guarantee. For example, when yous iterate over a HashMap, yous don't know inwards which company entries volition live traversed because HashMap doesn't render whatsoever ordering. Then, how tin yous sort a Map which doesn't back upward order? Well, yous can't together with that's why yous alone sort entries of HashMap but yous don't store the final result dorsum into HasMap or whatsoever other Map which doesn't back upward ordering. If yous produce so, together with then sorting volition live lost.

Here is an event of wrong sorting. Here fifty-fifty after sorting the Map, nosotros are doing the fault of storing the final result dorsum into a Map which doesn't render whatsoever ordering guarantee, thence the final result is an unordered map fifty-fifty after sorting.

Map sorted = budget .entrySet() .stream() .sorted(comparingByKey()) .collect(toMap(e -> e.getKey(), e -> e.getValue(), (e1, e2) -> e2));

Here is the output to confirm what I said:

map before sorting: {grocery=150, utility=130, miscellneous=90,  rent=1150, clothes=120, transportation=100} map after sorting past times keys: {grocery=150, utility=130, miscellneous=90,  rent=1150, clothes=120, transportation=100}

If Map was sorted together with then the "clothes" should receive got come upward rootage ahead of "grocery". The fault was blindly relying on toMap() method of Collectors class. This degree provides no guarantee of what form of Map volition live used to collect those elements. Since Map interface doesn't guarantee order, they are too non outpouring to store chemical cistron inwards whatsoever order.

Though, it's slowly to solve this work because Collectors degree too render an overloaded version of toMap() degree which allows yous to instruct which form of Map should live used to store those entries. You tin usage a LinkedHashMap to store mappings to save the sorting company because LinkedHashMap continue keys inwards the company they were added. Here is the modified code which sorts a Map inwards the company of keys:

Map sorted = budget .entrySet() .stream() .sorted(comparingByKey()) .collect(toMap(e -> e.getKey(), e -> e.getValue(), (e1, e2) -> e2), LinkedHashMap::new));

The code passed into to toMap() method is interesting, the rootage parameter is used equally a key, minute is used equally value together with tertiary is used to suspension ties i.e. if 2 entries are equal together with then which entries volition live chosen is decided past times the tertiary parameter, hither nosotros are using the minute entry. The 4th parameter is the of import one, which uses a constructor reference to say Collector that for copying a LinkedHashMap should live used.  See Java SE 8 for the Really Impatient to larn to a greater extent than virtually how constructor interference is used.

Steps to sort a Map past times keys inwards Java 8

Here are the high-level steps yous tin convey to sort a Map e.g. HashMap, Hashtable, ConcurentHashMap or LinkedHashMap to sort them inwards the ascending together with descending company of their keys:

1) Get all entries past times calling the Map.entrySet() method

2) Get a current of entries past times calling the stream() method, which Set inherit from Collection interface.

3) Sort all entries of Stream past times calling the sorted() method.

4) In company to sort them past times keys, render a Comparator to a sorted() method which sorts entries past times keys. This tin live done past times calling Map.Entry.comparingKey() method returns a Comparator which compares primal inwards their natural order.

5) Store the final result of sorting inwards a LinkedHashMap past times using the collect() method of Stream class.

6) Use Collectors.toMap() method to collect sorted entries into LinkedHashMap

Java Program to sort a Map past times keys inwards JDK 8

Here is the consummate Java programme to sort Map e.g. HashMap past times keys inwards JDK 8. In this example, yous volition larn to sort Map past times both lambda aspect together with method reference. We'll too usage novel classes e.g. Stream together with novel methods added into Map.Entry degree to sort all entries past times their Map together with store the final result into a LinkedHashMap.

import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map;  import static java.util.stream.Collectors.*; import static java.util.Map.Entry.*;  /* * Java Program to sort a Map past times keys inwards Java 8 *  */ public class Java8Demo{  public static void main(String[] args) throws Exception {  // a Map amongst string keys together with integer values Map<String, Integer> budget = new HashMap<>(); budget.put("clothes", 120); budget.put("grocery", 150); budget.put("transportation", 100); budget.put("utility", 130); budget.put("rent", 1150); budget.put("miscellneous", 90);  System.out.println("map before sorting: " + budget);  // let's sort this map past times keys first Map<String, Integer> sorted = budget .entrySet() .stream() .sorted(comparingByKey()) .collect( toMap(e -> e.getKey(), e -> e.getValue(), (e1, e2) -> e2, LinkedHashMap::new));  System.out.println("map after sorting past times keys: " + sorted);  // inwards a higher house code tin live cleaned a flake past times using method reference sorted = budget .entrySet() .stream() .sorted(comparingByKey()) .collect( toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));   // at 1 time let's sort the map inwards decreasing company of keys sorted = budget .entrySet() .stream() .sorted(Collections.reverseOrder(Map.Entry.comparingByKey())) .collect( toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));  System.out.println("map after sorting past times keys inwards descending order: " + sorted); }  }  Output map before sorting: {grocery=150, utility=130, miscellneous=90,         rent=1150, clothes=120, transportation=100} map after sorting past times keys: {clothes=120, grocery=150, miscellneous=90,         rent=1150, transportation=100, utility=130} map after sorting past times keys inwards descending order: {utility=130,         transportation=100, rent=1150, miscellneous=90, grocery=150, clothes=120}

You tin run into that initially map was non sorted but it is afterwards sorted inwards the company of keys, which are a string together with that's why clothe come upward ahead of grocery. Similarly, when nosotros sorted the map inwards the descending order, clothe come upward last. This proves that our sorting code is working fine.


If yous desire to a greater extent than sophistication together with customization yous tin produce that at Comparator aeroplane together with yous tin render additional Comparator to comparingKey() method, which past times default compare keys inwards their natural order.

For example, if a primal were non String but a user object e.g. a Book, together with then yous could receive got sorted mass past times title, writer or toll past times providing the corresponding comparator to comparingKey() method of java.util.Map.Entry class. Both comparingKey() together with comparingValue() are overloaded to convey a Comparator. You tin run into a practiced Java 8 mass e.g. Java SE 8 for Really Impatient to larn to a greater extent than virtually them.

That's all virtually how to sort a Map past times keys inwards Java 8. The simplest agency to compass this is past times using the sorted() method of Stream together with the newly added comparingKey() method of Map.Entry class. The current sorts all elements together with and then depending upon your need, yous tin either impress entries inwards sorted company or stored them inwards an ordered map e.g. LinkedHashMap or a sorted map e.g. TreeMap. You tin too sort entries inwards their contrary company past times simply reversing the Comparator using the Collections.reverseOrder() method or Comparator.reversed() method of Java 8.


Further Learning
The Complete Java MasterClass
Java SE 8 Developer BootCamp
Refactoring to Java 8 Streams together with Lambdas Self- Study Workshop

Related Java 8 Tutorials
If yous are interested inwards learning to a greater extent than virtually novel features of Java 8, hither are my before articles roofing unopen to of the of import concepts of Java 8:

• 20 Examples of Date together with Time inwards Java 8 (tutorial)
• How to usage Stream degree inwards Java 8 (tutorial)
• How to usage filter() method inwards Java 8 (tutorial)
• How to usage forEach() method inwards Java 8 (example)
• How to bring together String inwards Java 8 (example)
• How to convert List to Map inwards Java 8 (solution)
• How to usage peek() method inwards Java 8 (example)
• 5 Books to Learn Java 8 from Scratch (books)

Thank for reading this article so far. If yous similar this tutorial together with then delight percentage amongst your friends together with colleagues. If yous receive got whatsoever enquiry or feedback together with then delight drib a comment.

P.S. : If yous desire to larn to a greater extent than virtually novel features inwards Java 8 together with then delight run into the tutorial What's New inwards Java 8. It explains virtually all of import features of Java 8 e.g. lambda expressions, streams, functional inteface, Optionals, novel appointment together with fourth dimension API together with other miscelleneous changes.

Bagikan Artikel ini