How to sort a Map in Java by its String keys which are numeric

Question

I have created a map called result.

In the sortByKeys method as my keys are String with Numeric values, I have converted them to Integer key type Map then sorted them.

The sorting is working fine when I am looping and printing individually, but not when I am setting them in another Map.

public class TestDate {
    public static void main (String args[]){

    Map<String, String> result = new HashMap<String, String>();

        result.put("error", "10");
        result.put("1","hii");
        result.put("Update","herii");
        result.put("insert","insert");
        result.put("10","hiiuu");
        result.put("7","hii");
        result.put("21","hii");
        result.put("15","hii"); 

        Map<String, String> sorted = sortByKeys(result);
        //System.out.println(sorted);   
    }

    private static Map<String, String> sortByKeys(Map<String, String> map) {
        Map <Integer,String> unSorted = new  HashMap<Integer, String>();
        Map <String,String> sorted = new  HashMap<String, String>();
        for (Map.Entry<String, String> entry : map.entrySet())
        {
            try{
                int foo = Integer.parseInt(entry.getKey());            
                unSorted.put(foo, entry.getValue());                
            }catch (Exception e){

            }
        }
        Map<Integer, String> newMap = new TreeMap<Integer, String>(unSorted); 
        Set set = newMap.entrySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            Map.Entry me = (Map.Entry)iterator.next();
            System.out.println(me.getKey());
            System.out.println(me.getValue());
            sorted.put(me.getKey().toString(),  me.getValue().toString());

       }
        System.out.println(sorted);

        return null;
    }   
}

Here is the o/p :

1
hii
7
hii
10
hiiuu
15
hii
21
hii
{21=hii, 10=hiiuu, 1=hii, 7=hii, 15=hii}

Answer 1

If you don't need the last inch of performance, you can solve this rather directly, without an extra step to sort the map, by using SortedMap:

Map<String,String> result = new TreeMap<>(Comparator.comparingInt(Integer::parseInt));

If you are among the unfortunate bunch who are still being denied access to Java 8, you'll have to implement the Comparator in long-hand:

new TreeMap<>(new Comparator<String,String> { public int compare(String a, String b) {
  return Integer.compare(Integer.parseInt(a), Integer.parseInt(b));
}});

The above approach works only under the assumption that all keys are parseable integers. If that is not the case, then you won't be able to use the SortedMap directly, but transform your original map into it, filtering out the unparseable keys.

Answer 2

It's because the Map you're putting them into is a HashMap, which isn't sorted. There's no guarantee of the ordering of results you'll get out of the HashMap, even if you put them in in the right order.

(And calling it sorted doesn't change anything :) )