Sort HashMap in Java based on Values

Using AraryList with Comparator:

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.Map.Entry;

public class SortByKeyListComp {

     private static void printSortedMap(Map<String, Integer> map) {

           /* Create the entry set. */

           Set<Entry<String, Integer>> set = map.entrySet();

          

           /* Create a list from EntrySet. */

           List<Entry<String, Integer>> list = new ArrayList<Entry<String, Integer>>(set);

          

           /* Sort List using the comparator. */

           Collections.sort( list, newComparator<Map.Entry<String, Integer>>() {

                public intcompare( Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {

                     return (o2.getValue()).compareTo(o1.getValue() );

                }

           });

          

           /* Print data. */

           for(Map.Entry<String, Integer> entry: list) {

                System.out.println("key#"+entry.getKey()+" value#"+entry.getValue());

           }

     }

    

     /**

      * Driver Method.

      */

     public static void main(String[] args) {

           Map<String, Integer> map = newHashMap<String, Integer>();

           map.put("geeks", 3);

           map.put("nerd", 2);

           map.put("test", 7);

          

           printSortedMap(map);

     }

}

Using TreeMap with Comparator:

import java.util.Comparator;

import java.util.HashMap;

import java.util.Map;

import java.util.TreeMap;

class ValueComparator implements Comparator {

     Map map;

     /* Set Map in Constructor. */

     public ValueComparator(Map map) {

           this.map = map;

     }

     /**

      * Compare the values using the default value of the Map.

      */

     public intcompare(Object keyA, Object keyB) {

           Comparable valueA = (Comparable) map.get(keyA);

           Comparable valueB = (Comparable) map.get(keyB);

           return valueB.compareTo(valueA);

     }

}

public class SortByKeyTreeComp {

     public static Map sortByValue(Map unsortedMap) {

           /* Pass Map to ValueComparator so we can compare on the basic from defualt key.*/

           ValueComparator vc = newValueComparator(unsortedMap);

           Map sortedMap = newTreeMap(vc);

           sortedMap.putAll(unsortedMap);

           return sortedMap;

     }

     public static void main(String[] args) {

           HashMap<String, Integer> map = newHashMap<String, Integer>();

           map.put("geeks", 3);

           map.put("nerd", 2);

           map.put("test", 7);

           System.out.println(map);

           Map sortedMap = sortByValue(map);

           System.out.println(sortedMap);

     }

}

Comparable vs. Comparator

Comparable: java.lang	Comparator: java.util
1) It provides single sorting sequence. We can sort on particular single scenario.	It provides multiple sorting sequences. We can provide different comparator to sort.
2) Comparable affects the original class i.e. actual class is modified.	Comparator doesn't affect the original class i.e. actual class is not modified.
3) Comparable provides compareTo() method to sort elements.	Comparator provides compare() method to sort elements.
4) We can sort the list elements of Comparable type by Collections.sort(List) method.	We can sort the list elements of Comparator type by Collections.sort(List,Comparator) method.

package com.comparator;

import java.util.Comparator;

public class StringComparator implements Comparator<String>{

       @Override

       public int compare(String objStr1, String objStr2) {

              int result = 0;

              if(objStr1!=null && objStr2!=null) {

                     result = -1 * objStr1.compareTo(objStr2);

              }

              return result;

       }

}

package com.comparator;

import java.util.Map;

import java.util.TreeMap;

public class TestComparator {

       public static void main(String[] args) {

             

              /**

               * Default Sorting accoding to comparable implemetation of

               * string class in ascending order.

               */

              Map<String,String> map = new TreeMap<String,String>();

              map.put("A", "1");

              map.put("B", "2");

              map.put("C", "3");

             

              System.out.println(map);

             

              /**

               * Using external comparator sort String keys in descending order.

               */

              StringComparator comparator = new StringComparator();

              Map<String,String> compMap = new TreeMap<String,String>(comparator);

              compMap.put("A", "1");

              compMap.put("B", "2");

              compMap.put("C", "3");

             

              System.out.println(compMap);

       }

}

Output:

{A=1, B=2, C=3}

{C=3, B=2, A=1}