Sort a HashMap based on a Value object's attribute

[Arnav Velimala]

Hi,

Am trying to sort a Map based on a value object's attribute.
The Map has supplierId(String) as Keys and Supplier object as value. The Map has to be sorted on the Supplier object's name.

But the following code doesn't work!!

  
private Map sortDataOnSupplierName(Map unsortedMap) {

		Map sortedMap = new HashMap();

		List list = new ArrayList(unsortedMap.entrySet());

		java.util.Collections.sort(list, new Comparator() {

			public int compare(Object o1, Object o2) {
				Map.Entry entry1 = (Map.Entry) o1;
				Map.Entry entry2 = (Map.Entry) o2;

				String supplierName1 = ((Supplier) entry1.getValue())
						.getSupplierName();
				String supplierName2 = ((Supplier) entry2.getValue())
						.getSupplierName();
				return supplierName1.compareTo(supplierName2);
				
			}
		});

		for (Iterator listIt = list.iterator(); listIt.hasNext();) {
			Map.Entry sitePairs = (Map.Entry) listIt.next();
			sortedMap.put(sitePairs.getKey(), sitePairs.getValue());
		}
		return sortedMap;
	}
  

  
public class Supplier extends Entity {

	private static final long serialVersionUID = -5943533383210980156L;

	private String supplierID;

	private String supplierName;

	/**
	 * siteID and siteName are stored in the map as key-value pairs.
	 */
	private Map sites = new HashMap();

....

}

  

Can anyone tell me what's wrong in my code?

Thanks,
Arnav

[Rob Spoor]

The list is sorted, but then you put it in a "sorted" map. However, HashMap is not sorted, and it will never be sorted. There is currently only one map that is sorted, and that is TreeMap.

The problem is that any comparator for a TreeMap needs a reference to the TreeMap to be able to sort it. However, it needs to provide the comparator to the TreeMap constructor, so you can't put a reference to the TreeMap right away.

The following may work (I haven't tested it):

private static class TreeMapComparator implements Comparator
{
    private Map map;

    public int compare(Object o1, Object o2)
    {
        if (map == null) return 0;
        Supplier sup1 = (Supplier)map.get(o1);
        Supplier sup2 = (Supplier)map.get(o2);
        // handle the case where either one is null
        return sup1.getSupplierName().compareTo(sup2.getSupplierName());
    }

    public void setMap(Map map) { this.map = map; }
}

TreeMapComparator comp = new TreeMapComparator();
SortedMap map = new TreeMap(comp);
comp.setMap(map);
// add items

The TreeMapComparator should be a static nested class in your current class; its definition is not needed outside of it, only the fact that it is a Comparator.


Edit: of course you can use a LinkedHashMap; that keeps the insertion order. It won't stay ordered if you put new items though, but I'm not quite sure my above solution will handle that well.

[Sebastian Janisch]

I would rather use this form of implementation:

public class Supplier extends Entity implements Comparable<Supplier> {

	private static final long serialVersionUID = -5943533383210980156L;

	private String supplierID;

	private String supplierName;

	/**
	 * siteID and siteName are stored in the map as key-value pairs.
	 */
	private Map sites = new HashMap();

    public int compareTo (Supplier otherObject) {
       return this.getSupplierName.compareTo(otherObject.getSupplierName());
    }

}


public class ImplementingClass {
    List<Supplier> mySuppliers = new ArrayList<Supplier> ();

    /*
     * fill your list
     */
    Collections.sort(mySuppliers);
}

and thats it.

You can also take away the Comparable from the Supplier class and use a Comparator when sorting.

[Arun Singh Raaj]

public class Test {
public static void main(String[] args) {
TreeMap<Integer, String> hm=new TreeMap();
hm.put(3, "arun singh");
hm.put(5, "vinay singh");
hm.put(1, "bandagi singh");
hm.put(6, "vikram singh");
hm.put(2, "panipat singh");
hm.put(28, "jakarta singh");

ArrayList<String> al=new ArrayList(hm.values());
Collections.sort(al, new myComparator());

System.out.println("//sort by values \n");
for(String obj: al){
    for(Map.Entry<Integer, String> map2:hm.entrySet()){
        if(map2.getValue().equals(obj)){
            System.out.println(map2.getKey()+" "+map2.getValue());
        }
    } 
 }
}
}

class myComparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
     String o3=(String) o1;
     String o4 =(String) o2;
return o3.compareTo(o4);
    }   
}

OUTPUT=

//sort by values 

3 arun singh
1 bandagi singh
28 jakarta singh
2 panipat singh
6 vikram singh
5 vinay singh

[Campbell Ritchie]

You will have seen from the earlier posts that it is impossible to sort a hash map. What you are doing is sort a List and then finding the Map.Entry in the Map with the corresponding “V”. What you are actually doing is sorting a List<String>, which is a completely different task.

By the way: Why are you using a Comparator to sort something which already implements Comparable?

[Arun Singh Raaj]

Ya, it is true that Map cannot be sorted by values straight.
And you are right, it could have been done by implementing Comparable interface to the Employee, But  i actually had a case in my mind that if the 'value' of the map object is user-defined type then you could have had Comparator implemented.

By the way, if i had the requirement to sort Map by value then does my way of converting Map values into List then finding it through the EntrySet, slow down the performance?

[Campbell Ritchie]

Arun Singh Raaj wrote:. . . does my way of converting Map values into List then finding it through the EntrySet, slow down the performance?

What do you think? Look at how many loops you have written.

[Piet Souris]

Why not have a List<Map.Entrry> with a suitable Comparator?

[Stephan van Hulst]

Such a comparator can easily be created like this:

Map.Entry.comparingByValue(Comparator.comparing(Foo::property));

Or even simpler, when you want to compare the values themselves and not a property of the values:

Map.Entry.comparingByValue();