# Sort HashMap by value

Hi!! Welcome to flower brackets blog. Today we are going to learn sort hashmap by value.

So to sort hashmap we have to insert some key and values and create a linkedlist from the map entries.

Also read – merge sort java

Hashmap does not maintain order by default. If there is a need we need to sort it explicitly based on requirement.

Now let’s us see code implementation of hashmap sort by key,

#### Java hashmap sort by key

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

public class HashMapByKey
{
public static void main(String[] args)
{
HashMap<Integer, String> hm = new HashMap<Integer, String>();
hm.put(4, "dhoni");
hm.put(3, "virat");
hm.put(6, "ajith");
hm.put(2, "bharath");
hm.put(1, "chetesh");
hm.put(5, "kapil");
hm.put(7, "ishant");

System.out.println("Java sorted map by key - Before Sorting : ");
Set set = hm.entrySet();
Iterator ir = set.iterator();
while(ir.hasNext())
{
Map.Entry me = (Map.Entry)ir.next();
System.out.print(me.getKey() + " : ");
System.out.println(me.getValue());
}
Map<Integer, String> map = new TreeMap<Integer, String>(hm);
System.out.println("Java sorted map by key - After Sorting : ");
Set set2 = map.entrySet();
Iterator ir2 = set2.iterator();
while(ir2.hasNext())
{
Map.Entry me2 = (Map.Entry)ir2.next();
System.out.print(me2.getKey() + " : ");
System.out.println(me2.getValue());
}
}
}

```

Output :

```Java sorted map by key - Before Sorting :
4 : dhoni
3 : virat
6 : ajith
2 : bharath
1 : chetesh
5 : kapil
7 : ishant
Java sorted map by key - After Sorting :
1 : chetesh
2 : bharath
3 : virat
4 : dhoni
5 : kapil
6 : ajith
7 : ishant

```

#### Using comparator

To sort hashmap by value first we need to store entry value set in list and sort list on basis of values.

Also read – palindrome string in java

Next we have to retrieve value and key from list and place in new hashmap. Lastly hashmap should be sorted according to values.

```import java.text.ParseException;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class HashMapExample
{
public static void main(String[] args) throws ParseException
{
HashMap<String, Integer> hm = new HashMap<String, Integer>();

// add data into hashmap
hm.put("Orange", 4);
hm.put("Mango", 3);
hm.put("Strawberry", 6);
hm.put("Cherry", 2);
hm.put("Apple", 1);
hm.put("Grape", 7);
Map<String, Integer> map = hashByValue(hm);

System.out.println("Sorting a hashmap by value in java - ");
// printing sorted hashmap
for(Map.Entry<String, Integer> me : map.entrySet())
{
System.out.println("Key = " + me.getKey() + ", Value = " + me.getValue());
}
}

// this function sorts hashmap by value
public static HashMap<String, Integer> hashByValue(HashMap<String, Integer> hm)
{
// creating list from hashmap elements
List<Map.Entry<String, Integer>> li = new LinkedList<Map.Entry<String, Integer> >(hm.entrySet());

// here we are sorting the list
Collections.sort(li, new Comparator<Map.Entry<String, Integer>>()
{
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2)
{
return (o1.getValue()).compareTo(o2.getValue());
}
});

// add data from sorted list to hashmap
HashMap<String, Integer> ha = new LinkedHashMap<String, Integer>();
for(Map.Entry<String, Integer> aa : li)
{
ha.put(aa.getKey(), aa.getValue());
}
return ha;
}
}

```

Output:

```Sorting a hashmap by value in java -
Key = Apple, Value = 1
Key = Cherry, Value = 2
Key = Mango, Value = 3
Key = Orange, Value = 4
Key = Strawberry, Value = 6
Key = Grape, Value = 7

```

Java map comparator – generic types

Now we will learn treemap sort by value in descending order,

```import java.util.Comparator;
import java.util.HashMap;
import java.util.TreeMap;

public class HashMapByValue
{
public static void main(String[] args)
{
// String and Integer HashMap
HashMap<String, Integer> hm = new HashMap<String, Integer>();
hm.put("aa", 1);
hm.put("bb", 3);
hm.put("cc", 5);
hm.put("dd", 4);
hm.put("ee", 2);
System.out.println(hm);

Comparator<String> com = new ValueComparator<String, Integer>(hm);
TreeMap<String, Integer> output = new TreeMap<String, Integer>(com);
output.putAll(hm);

System.out.println(output);

// Integer and Integer HashMap
HashMap<Integer, Integer> hm2 = new HashMap<Integer, Integer>();
hm2.put(1, 11);
hm2.put(2, 31);
hm2.put(3, 51);
hm2.put(4, 41);
hm2.put(5, 21);
System.out.println(hm2);

Comparator<Integer> com2 = new ValueComparator<Integer, Integer>(hm2);
TreeMap<Integer, Integer> output2 = new TreeMap<Integer, Integer>(com2);
output2.putAll(hm2);

System.out.println(output2);
}
}

// comparator using generic type
class ValueComparator<K, V extends Comparable<V>> implements Comparator<K>
{
HashMap<K, V> map = new HashMap<K, V>();

public ValueComparator(HashMap<K, V> map)
{
this.map.putAll(map);
}

@Override
public int compare(K s1, K s2)
{
// java sort hashmap by value descending
return -map.get(s1).compareTo(map.get(s2));
}
}

```

Output :

```{aa=1, bb=3, cc=5, dd=4, ee=2}
{cc=5, dd=4, bb=3, ee=2, aa=1}
{1=11, 2=31, 3=51, 4=41, 5=21}
{3=51, 4=41, 2=31, 5=21, 1=11}

```