Compare HashMap with Objects

Question

I've got a hashmap<CustomObject,Integer> and I'd like to compare the Integers (values) within each entry. So, basically I'd like to sort my values by their Integer value in descending order. I've got a Comparator which consists of the following...

class Compare implements Comparator<Integer>{
    Map<CustomObject,Integer> map;
    /**
     * Constructs our map
     * @param map map to be sorted.
     */
    public Compare(Map<CustomObject,Integer> map){
        this.map = map;
    }
    /**
     * Performs the comparison between two entries.
     */
    public int compare(Integer one, Integer two){
        if(map.get(one) <= map.get(two)){
            return 1;
        }else{
            return 0;
        }
    }
}

I pass my Hashmap into the TreeMap by calling the following line of code.. Tmap.putAll(Hmap);. Where Tmap and Hmap are defined as:

private HashMap<CustomObject,Integer> Hmap;
private TreeMap<CustomObject,Integer> Tmap;

When I run my code I get the error Exception in thread "main" java.lang.ClassCastException: CustomObject cannot be cast to java.lang.Comparable.

The exception appears to be called when I attemp to extract a value from my sorted list. like so...

TreeMap<CustomObject,Integer> sorted = Tmap.putAll(hmap);
sorted.get(o);

where o is a CustomObject.

I think I've misunderstood how comparator works.. what am I doing wrong? How would I compare the two Integer values?

EDIT

Just to clarify what I'm actually trying to do...

I want to compare Integers which are linked to a CustomObject. I can't make the key the Integer because these Integers may not be unique. I was to compare them because I'd like to sort my collection in descending order based on their Integer value.

Answer 1

You need to change your comparator to compare CustomObjects, not Integers:

class Compare implements Comparator<CustomObject>{
    Map<CustomObject,Integer> map;
    /**
     * Constructs our map
     * @param map map to be sorted.
     */
    public Compare(Map<CustomObject,Integer> map){
        this.map = map;
    }
    /**
     * Performs the comparison between two entries.
     */
    public int compare(CustomObject left, CustomObject right){
        return map.get(left).compareTo(map.get(right));
    }
}

Then, you need to tell the TreeMap to use your comparator:

private Map<CustomObject,Integer> Tmap = 
    new TreeMap<CustomObject,Integer>(new Compare(HMap));

Answer 2

new TreeMap<..>(new Compare<..>(map))

You have to specify the comparator when constructing the tree. Otherwise it assumes your keys are comparable (and they aren't)

But check this answer for sorting a map based on the values.

Answer 3

This approach has a few problems.

• TreeMap ignores duplicates (when compareTo returns 0) In your case it will only add decreasing integer values. You can fix it so the numbers can be in any order, but it would still drop any entries with duplicate values.
• The fields used in the compareTo cannot change or will corrupt the collection.
• You need to know the whole key to lookup a value. In this case, you need to know the value in this case to look it up which may not be very useful.

You are better off creating a List<Entry<CustomObject,Integer>> from the map.entrySet() which you can sort, as this allows duplicates and is ordered.

Answer 4

I think that the problem will be that you are using the wrong TreeMap constructor. The one you are using requires that all keys are instances of classes that implement Comparable. Your CustomObject does not. You should use the constructor that takes a Comparator parameter; e.g.

TreeMap<CustomObject,Integer> tmap = 
    new TreeMap<CustomObject,Integer>(new Compare());

This will also tell you that your Compare class needs to implement Comparator<CustomObject> not Comparator<Integer>.

Another problem is that your comparator is not implementing the correct semantics. The compare method should return a -ve number if arg1 < arg2, zero if arg1 = arg2 and a +ve number if arg1 > arg2; e.g.

public int compare(CustomObject one, CustomObject two){
    return Integer.compare(map.get(one), map.get(two));
}

And even this is dodgy:

• If any two CustomObject instances that map to the same integer will be treated as equal, and you won't be able to have both as (distinct) keys in the TreeMap.

• Your comparator will throw an NPE if there is no entry in map for one or two.

Answer 5

I would suggest using a multimap indexed by integer. If you need to retain the ability to look up these pairs by object you can maintain both maps. Java doesn't ship with a multimap but there are easy solutions. Here is an example of Map<Integer,List<Object>> (scroll down to the multimaps section).

Answer 6

First thin is that the key should be Integer and value should be CustomObject and then the HashMap can be sorted based on the comparator. But by default the HashMap or if you wan to sort on CustomObject then you have to make the CustomObject implements Comparable and write the compare method in that which will make the HashMap to sort based on CustomObject. If you have understood this. and want to try your self try. or if you want me to explain with an example I can do it.

The question is confusing.