Java Sort map by key说明

Question

I recently found a great way to sort a map that contains GregorianCalendar as keys.

Map<GregorianCalendar, String> map = new HashMap<>();

Map<GregorianCalendar, String> sortedMap = map.entrySet().stream().sorted(Map.Entry.comparingByKey()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
            (oldValue, newValue) -> oldValue, LinkedHashMap::new));

Can someone help me to understand each procedure called in this command especially going on from the stream function ?

Thanks

Answer 1

map.entrySet().stream() produces a Stream of the entries of the input Map (ie a Stream<Map.Entry<GregorianCalendar,String>> .

.sorted(Map.Entry.comparingByKey()) sorts the elements of this Stream by the keys of the entries (it relies on the fact that the key type - GregorianCalendar - implements Comparable ).

.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new))

produces a LinkedHashMap that contains the same entries as the input Map . Since you are using LinkedHashMap , the insertion order is maintained, and since you sorted the entries of the Stream by the keys, you get a Map whose insertion order (and iteration order) is according to the order of the keys.

Of course you can get a sorted Map more easily by putting all the entries of the input Map in a TreeMap :

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

This has the advantage of maintaining the order even if you add new entries to the Map .

Answer 2

First you sort entries by Key via sorted(Map.Entry.comparingByKey())

then these are are collected to a Map (the implementation underneath uses HashMap ), where the Key is of type GregorianCalendar and value is of type String . The code also supplies a merge function:

(oldValue, newValue) -> oldValue

where they keep the last value, when there is a collision, like a "last-wins" policy. So when these is a collision ( two same GregorianCalendar values ), you will always keep the second one, whatever second means here. Since your source for streaming is a HashMap that does not have a defined order, this "second" can change if you have add or remove values from your initial map.

Once those are sorted and you collect them to a HashMap (via collect ), you order can break, so the collecting happens in a LinkedHashMap basically preserving that sorted order

Answer 3

I just want to leave a generic method for such sorting because it was a bit tricky for me

private <K extends Comparable<? super K>,V> Map<K, V> sortMapByKey(Map<K, V> map) {

        return  map.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue,
                        LinkedHashMap::new));
    }