How To Assort A Map Past Times Keys Inwards Coffee Viii - Representative Tutorial

In the final article, I lead maintain shown yous how to sort a Map past times values inward Java 8 too inward 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 whatever ordering guarantee. For example, when yous iterate over a HashMap, yous don't know inward which fellowship entries volition live traversed because HashMap doesn't render whatever ordering. Then, how tin post away yous sort a Map which doesn't back upward order? Well, yous can't too that's why yous alone sort entries of HashMap but yous don't store the number dorsum into HasMap or whatever other Map which doesn't back upward ordering. If yous produce so, too then sorting volition live lost.

Here is an instance of wrong sorting. Here fifty-fifty after sorting the Map, nosotros are doing the error of storing the number dorsum into a Map which doesn't render whatever ordering guarantee, thus the number 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 too then the "clothes" should lead maintain come upward start ahead of "grocery". The error was blindly relying on toMap() method of Collectors class. This shape provides no guarantee of what sort of Map volition live used to collect those elements. Since Map interface doesn't guarantee order, they are likewise non jump to store chemical ingredient inward whatever order.

Though, it's slow to solve this job because Collectors shape likewise render an overloaded version of toMap() shape which allows yous to instruct which sort of Map should live used to store those entries. You tin post away occupation a LinkedHashMap to store mappings to save the sorting fellowship because LinkedHashMap move along keys inward the fellowship they were added. Here is the modified code which sorts a Map inward the fellowship 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 start parameter is used equally a key, minute is used equally value too tertiary is used to suspension ties i.e. if 2 entries are equal too then which entries volition live chosen is decided past times the tertiary parameter, hither nosotros are using the minute entry. The quaternary 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 nigh how constructor interference is used.

Steps to sort a Map past times keys inward Java 8

Here are the high-level steps yous tin post away convey to sort a Map e.g. HashMap, Hashtable, ConcurentHashMap or LinkedHashMap to sort them inward the ascending too descending fellowship of their keys:

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

2) Get a flow 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 fellowship to sort them past times keys, render a Comparator to a sorted() method which sorts entries past times keys. This tin post away live done past times calling Map.Entry.comparingKey() method returns a Comparator which compares cardinal inward their natural order.

5) Store the number of sorting inward 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 inward JDK 8

Here is the consummate Java plan to sort Map e.g. HashMap past times keys inward JDK 8. In this example, yous volition larn to sort Map past times both lambda aspect too method reference. We'll likewise occupation novel classes e.g. Stream too novel methods added into Map.Entry shape to sort all entries past times their Map too store the number 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 inward Java 8 *  */ public class Java8Demo{  public static void main(String[] args) throws Exception {  // a Map alongside string keys too 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);  // inward a higher house code tin post away live cleaned a combat past times using method reference sorted = budget .entrySet() .stream() .sorted(comparingByKey()) .collect( toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));   // straightaway let's sort the map inward decreasing fellowship 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 inward 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 inward descending order: {utility=130,         transportation=100, rent=1150, miscellneous=90, grocery=150, clothes=120}

You tin post away run into that initially map was non sorted but it is afterward sorted inward the fellowship of keys, which are a string too that's why wearing clothing come upward ahead of grocery. Similarly, when nosotros sorted the map inward the descending order, wearing clothing come upward last. This proves that our sorting code is working fine.


If yous desire to a greater extent than sophistication too customization yous tin post away produce that at Comparator score too yous tin post away render additional Comparator to comparingKey() method, which past times default compare keys inward their natural order.

For example, if a cardinal were non String but a user object e.g. a Book, too then yous could lead maintain sorted mass past times title, writer or cost past times providing the corresponding comparator to comparingKey() method of java.util.Map.Entry class. Both comparingKey() too comparingValue() are overloaded to lead maintain a Comparator. You tin post away run into a skillful Java 8 mass e.g. Java SE 8 for Really Impatient to larn to a greater extent than nigh them.

That's all nigh how to sort a Map past times keys inward Java 8. The simplest means to accomplish this is past times using the sorted() method of Stream too the newly added comparingKey() method of Map.Entry class. The flow sorts all elements too and then depending upon your need, yous tin post away either impress entries inward sorted fellowship or stored them inward an ordered map e.g. LinkedHashMap or a sorted map e.g. TreeMap. You tin post away likewise sort entries inward their opposite fellowship past times but 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 too Lambdas Self- Study Workshop

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

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

Thank for reading this article so far. If yous similar this tutorial too then delight portion alongside your friends too colleagues. If yous lead maintain whatever inquiry or feedback too then delight drib a comment.

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