Sorting a hashmap first with values then keys in java

Sort the following in descending order of values then keys. I amended the list to make it more interesting.

Map<String, Integer> map = Map.of("a", 8, "b", 2, "c", 4, "d",
                8, "e", 3, "f", 4, "g", 7, "h", 1, "i", 5, "j", 2);

First define a Comparator to use in sorting the Map entries. Each entry is represented by the Map.Entry class. That class offers methods comparingByValue() and comparingByKey().

The following code says, first sort by value, then by the key. These are sorted in natural order except the following reversed() method says reverse the sorting of all comparators prior. So the values will be sorted in reversed order and the keys in alphabetical order.

Comparator<Entry<String, Integer>> comp = Entry
        .<String, Integer>comparingByValue().reversed()
        .thenComparing(Entry.comparingByKey());

This streams the existing map's entrys and applies the comparator to the sort method. It then collects them in a linked hashMap to preserve the order. The merge function does not play a part in this but is syntactically required.

Map<String, Integer> lhmap =
        map.entrySet().stream().sorted(comp)
                .collect(Collectors.toMap(Entry::getKey,
                        Entry::getValue,
                        (a, b) -> a,      // merge function
                        LinkedHashMap::new));

lhmap.entrySet().forEach(System.out::println);

That code prints:

a=8
d=8
g=7
i=5
c=4
f=4
e=3
b=2
j=2
h=1

A HashMap is not necessarily ordered, and in fact does not guarantee that the key value pair orders wil lremain constant over time. From the docs:

Hash table based implementation of the Map interface. This implementation provides all of the optional map operations, and permits null values and the null key. (The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls.) This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.

If you want a sorted map, use a NavigableMap or SortedMap. There are a few options. TreeMap is probably the simplest.

A Red-Black tree based NavigableMap implementation. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used.

So to create a map with the keys in descending alphabetical order something like this should do the tick:

Comparator<String> comparator = new Comparator<>() {
    @Override
    public int compare(String o1, String o2) {      
        return o2.compareTo(o1);
    }
};

TreeMap<String, Integer> treeMap = new TreeMap<>(comparator);

This answer is using java 8 streams.

//LinkedHashMap preserve the ordering of elements in which they are inserted

LinkedHashMap<String, Integer> reverseSortedMap = new LinkedHashMap<>();
    unSortedMap.entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
            .forEachOrdered(x -> reverseSortedMap.put(x.getKey(), x.getValue()));
     
    System.out.println("Reverse Sorted Map   : " + reverseSortedMap);