Java 8 sort HashMap in natural order of values :

//Define one HashMap called idNameMap

//Insert Id-Name pairs into idNameMap
//Java 8 sorting using Entry.comparingByValue()
         
        Map<Integer, String> sortedIdNameMap
        = idNameMap.entrySet()
                   .stream()
                   .sorted(Entry.comparingByValue())
                   .collect(Collectors.toMap(Entry::getKey, Entry::getValue,
(e1,  e2) -> e1, LinkedHashMap::new));

 //Print idNameMap before and after sorting

To sort the same HashMap in the reverse order,

use Collections.reverseOrder() or Comparator.reverseOrder() as shown
in the below program.

//Java 8 sorting using Entry.comparingByValue()

         
        Map<Integer, String> sortedIdNameMap
        = idNameMap.entrySet()
                   .stream()
                   .sorted(Collections.reverseOrder(Entry.comparingByValue()))
                   
                 // OR 
                 // .sorted(Entry.comparingByValue(Comparator.reverseOrder()))
                    
                   .collect(Collectors.toMap(Entry::getKey, Entry::getValue,
(e1,  e2) -> e1, LinkedHashMap::new));
 
         
        //Print idNameMap before and after sorting
         
        System.out.println("Before Sorting : ");
         
        System.out.println(idNameMap);
         
        System.out.println("After Sorting : ");
         
        System.out.println(sortedIdNameMap);
    }
}

Java 8 Sort HashMap By Values Using Customized Comparator :

//Java 8 sorting using Entry.comparingByValue()
         
        Map<Integer, String> sortedIdNameMap
        = idNameMap.entrySet()
                   .stream()
                   .sorted(Entry.comparingByValue((o1, o2) -> o1.length() -
o2.length()))
                   .collect(Collectors.toMap(Entry::getKey, Entry::getValue,
(e1,  e2) -> e1, LinkedHashMap::new));
 
        //Print idNameMap before and after sorting
         
        System.out.println("Before Sorting : ");
         
        System.out.println(idNameMap);
         
        System.out.println("After Sorting : ");
         
        System.out.println(sortedIdNameMap);
    }
}

To sort the same HashMap in decreasing order of length of values, use

either Collections.reverseOrder() or else return o2.length() -
o1.length() instead of o1.length() - o2.length() as in the below program.

//Java 8 sorting using Entry.comparingByValue()

         
        Map<Integer, String> sortedIdNameMap
        = idNameMap.entrySet()
                   .stream()
                   .sorted(Entry.comparingByValue((o1, o2) -> o2.length() -
o1.length()))
                    
                   //OR
                   //.sorted(Collections.reverseOrder(Entry.comparingByValue((
o1, o2) -> o1.length() - o2.length())))
                    
                   .collect(Collectors.toMap(Entry::getKey, Entry::getValue,
(e1,  e2) -> e1, LinkedHashMap::new));
 
        //Print idNameMap before and after sorting
         
        System.out.println("Before Sorting : ");
         
        System.out.println(idNameMap);
         
        System.out.println("After Sorting : ");
         
        System.out.println(sortedIdNameMap);
    }
}

Map<String, Integer> studentMap = new HashMap<String, Integer>();

         
        studentMap.put("Jyous", 87);
        studentMap.put("Klusener", 82);
        studentMap.put("Xiangh", 91);
        studentMap.put("Lisa", 89);
        studentMap.put("Narayan", 95);
        studentMap.put("Arunkumar", 86);

Java 8 sort HashMap by keys in natural order :

Map<String, Integer> sortedStudentMap
                    = studentMap.entrySet()
                                .stream()
                                .sorted(Entry.comparingByKey())
                                .collect(Collectors.toMap(Entry::getKey,
Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
Java 8 sorting HashMap in natural reverse order of keys :
 Map<String, Integer> sortedStudentMap
                        = studentMap.entrySet()
                                    .stream()
                                    .sorted(Collections.reverseOrder(Entry.com
paringByKey()))
                                     
                                //  OR
                                //
.sorted(Entry.comparingByKey(Comparator.reverseOrder()))
                                     
                                    .collect(Collectors.toMap(Entry::getKey,
Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
         
        Java 8 sort HashMap by keys using customized Comparator :
Map<String, Integer> sortedStudentMap
                                = studentMap.entrySet()
                                            .stream()
                                            .sorted(Entry.comparingByKey((o1,
o2) -> o1.length() - o2.length()))
                                            .collect(Collectors.toMap(Entry::g
etKey, Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
To sort the same HashMap in decreasing order of length of keys, use
either Collections.reverseOrder() or else return o2.length() -
o1.length() instead of o1.length() - o2.length() as in the below program.
 Map<String, Integer> sortedStudentMap
                                = studentMap.entrySet()
                                            .stream()
                                            .sorted(Entry.comparingByKey((o1,
o2) -> o2.length() - o1.length()))
                                                           
                                         //  OR
                                        // 
.sorted(Collections.reverseOrder(Entry.comparingByKey((o1, o2) -> o1.length()
- o2.length())))
                                             
                                            .collect(Collectors.toMap(Entry::g
etKey, Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));

How To Sort HashMap By Keys Using TreeMap

(Before Java 8)?
inserting HashMap elements into TreeMap. It will sort the elements according to
supplied Comparator or in natural order if no Comparator is supplied.

Sorting HashMap according to natural order of keys

using TreeMap without Comparator :
Map<String, Integer> sortedStudentMap = new
TreeMap<>(studentMap);
Sorting HashMap in natural reverse order of
keys using TreeMap with Comparator :
Map<String, Integer> sortedStudentMap = new
TreeMap<>(Collections.reverseOrder());
                 
        sortedStudentMap.putAll(studentMap);
Sorting HashMap by keys using TreeMap with customized Comparator :
Map<String, Integer> sortedStudentMap = new TreeMap<>(new
Comparator<String>()
        {
            @Override
            public int compare(String o1, String o2)
            {                                          
                return o1.length() - o2.length();
            }                                  
        });
                 
        sortedStudentMap.putAll(studentMap);
To sort the same HashMap in decreasing order of length of keys, use
either Collections.reverseOrder() or else return o2.length() -
o1.length() instead of o1.length() - o2.length() as in the below program
Map<String, Integer> sortedStudentMap = new TreeMap<>(new
Comparator<String>()
        {
            @Override
            public int compare(String o1, String o2)
            {
                return o2.length() - o1.length();
            }
        });
                 
//      OR
         
//      Map<String, Integer> sortedStudentMap = new
TreeMap<>(Collections.reverseOrder(new Comparator<String>()
//      {
//          @Override
//          public int compare(String o1, String o2)
//          {
//              return o1.length() - o2.length();
//          }
//      }));
         
        sortedStudentMap.putAll(studentMap);