Home » Java » how to sort Map values by key in Java

how to sort Map values by key in Java

Posted by: admin November 2, 2017 Leave a comment


I have a Map in java that has strings for both .

Data is like following: <"question1", "1">, <"question9", "1">, <"question2", "4">, <"question5", "2">

I want to sort the map based on its keys. So In the end I will have question1, question2, question3….an so on.

Eventually I am trying to get two strings out of this Map. First String: Questions ( in order 1 ..10) and Second String: Answers (in same order as question).

Right now I have the following:

Iterator it = paramMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry)it.next();
 questionAnswers += pairs.getKey()+",";

This gets me the questions in a string but they are not in order…


Short answer

Use a TreeMap. This is precisely what its for.

If this map is passed to you and you cannot determine the type, then you can do the following:

SortedSet<String> keys = new TreeSet<String>(map.keySet());
for (String key : keys) { 
   String value = map.get(key);
   // do something

This will iterate across the map in natural order of the keys.

Longer answer

Technically, you can use anything that implements SortedMap, but except for rare cases this amounts to TreeMap, just as using a Map implementation typically amounts to HashMap.

For cases where your keys are a complex type that doesn’t implement Comparable or you don’t want to use the natural order then TreeMap and TreeSet have additional constructors that let you pass in a Comparator:

// placed inline for the demonstration, but doesn't have to be an anonymous class
Comparator<Foo> comparator = new Comparator<Foo>() {
  public int compare(Foo o1, Foo o2) {
SortedSet<Foo> keys = new TreeSet<Foo>(comparator);

Remember when using a TreeMap or TreeSet that it will have different performance characteristics than HashMap or HashSet. Roughly speaking operations that find or insert an element will go from O(1) to O(Log(N)).

In a HashMap, moving from 1000 items to 10,000 doesn’t really affect your time to lookup an element, but for a TreeMap the lookup time will be about 3 times slower (assuming Log2). Moving from 1000 to 100,000 will be about 6 times slower for every element lookup.


Assuming TreeMap is not good for you (and assuming you can’t use generics):

List sortedKeys=new ArrayList(yourMap.keySet());
// Do what you need with sortedKeys.


Using the TreeMap you can sort the Map.

Map<String, String> map = new HashMap<String, String>();        
Map<String, String> treeMap = new TreeMap<String, String>(map);
for (String str : treeMap.keySet()) {


Use a TreeMap!


If you already have a map and would like to sort it on keys, simply use :

Map<String, String> treeMap = new TreeMap<String, String>(yourMap);

A complete working example :

import java.util.HashMap;
import java.util.Set;
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;

class SortOnKey {

public static void main(String[] args) {
   HashMap<String,String> hm = new HashMap<String,String>();
   Map<String, String> treeMap = new TreeMap<String, String>(hm);

public static void printMap(Map<String,String> map) {
    Set s = map.entrySet();
    Iterator it = s.iterator();
    while ( it.hasNext() ) {
       Map.Entry entry = (Map.Entry) it.next();
       String key = (String) entry.getKey();
       String value = (String) entry.getValue();
       System.out.println(key + " => " + value);



Just use TreeMap

new TreeMap<String, String>(unsortMap);


Provided you cannot use TreeMap, in Java 8 we can make use of toMap() method in Collectorswhich takes following parameters:

  • keymapper: mapping function to produce keys
  • valuemapper: mapping function to produce values
  • mergeFunction: a merge function, used to
    resolve collisions between values associated with the same key
  • mapSupplier: a function which returns a new, empty Map into which the
    results will be inserted.

Java 8 Example

Map<String,String> sample = new HashMap<>();  // push some values to map  
Map<String, String> newMapSortedByKey = sample.entrySet().stream()
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
Map<String, String> newMapSortedByValue = sample.entrySet().stream()
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));

We can modify the example to use custom comparator and to sort based on keys as:

Map<String, String> newMapSortedByKey = sample.entrySet().stream()
                .sorted((e1,e2) -> e1.getKey().compareTo(e2.getKey()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));


This code can sort a key-value map in both orders i.e. ascending and descending.

<K, V extends Comparable<V>> Map<K, V> sortByValues
     (final Map<K, V> map, int ascending)
     Comparator<K> valueComparator =  new Comparator<K>() {         
        private int ascending;
        public int compare(K k1, K k2) {
            int compare = map.get(k2).compareTo(map.get(k1));
            if (compare == 0) return 1;
            else return ascending*compare;
        public Comparator<K> setParam(int ascending)
            this.ascending = ascending;
            return this;

    Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
    return sortedByValues;

As an example:

Map<Integer,Double> recommWarrVals = new HashMap<Integer,Double>();
recommWarrVals = sortByValues(recommWarrVals, 1);  // Ascending order
recommWarrVals = sortByValues(recommWarrVals,-1);  // Descending order

List<String> list = new ArrayList<String>();
Map<String, String> map = new HashMap<String, String>();
for (String str : map.keySet()) {
for (String str : list) {


We can also sort the key by using Arrays.sort method.

Map<String, String> map = new HashMap<String, String>();
Object[] objArr = new Object[map.size()];
for (int i = 0; i < map.size(); i++) {
objArr[i] = map.get(i);
for (Object str : objArr) {