Question

so I’m not well versed in overriding hashCode and I seem to have some infinite recursion somehow going on with the hashCode method.

Here is my scenario, I have a class DuplicateCache that is a cache object that checks for duplicate objects in our system. I have a static inner class Duplicate which represents the Duplicate objects.

The DuplicateCache maintains a HashMap to keep track of all its entries. Each entry consists of a Duplicate object as the key and a Long object as the value.

I am performing all my operations using the Duplicate object keys, and when I run the put method into the HashMap, there becomes infinite recursion in the hashCode() method of the Duplicate object.

The hashCode() method in duplicate calls a hashCode of another class I had to override, so I’ll include that after

Without further ado, here is my code for the offending Duplicate class:

public static class Duplicate{
    private String merchId;
    private String custId;
    private MagicPrice price;
    private int status;
    private boolean compareStatus;

// snip methods        

    @Override public boolean equals(Object o){
        cat.debug("In the override equals method of Duplicate"); //DELETEME

        if(o instanceof Duplicate)
            return equals((Duplicate) o);
        else
            return false;
    }

    @Override public int hashCode() {
        return merchId.hashCode() + custId.hashCode() + price.hashCode();
    }


    /*Equals method vital to the HashMap cache operations

    How the compareStatus and status fields change this:
    if both objects have true for compareStatus -> Equals will compare the statuses
    otherwise                                   -> Equals will not compare the statuses

    If we only want to do an in_progress check, we need to compare status.
    On the other hand success checks need to ignore the status.
    */
    public boolean equals(Duplicate d){        
        try{
            if(merchId.equals(d.merchId) && custId.equals(d.custId) && (price.compareTo(d.price)==0)){
                if(this.compareStatus && d.compareStatus && this.status != d.status)
                    return false;

                return true;
            }
        }catch(PriceException pe){
            //Catching from MagicPrice.compareTo object method, return false
            return false;
        }

        return false;
    }        
}

That does it for the Duplicate object, now the MagicPrice hashCode() method:

@Override public boolean equals(Object o){
    if(!(o instanceof MagicPrice))
        return false;

    MagicPrice p = (MagicPrice)o;

    if(this.iso4217code.equals(p.iso4217code) && this.value.equals(p.value))
        return true;

    else return false;
}

@Override public int hashCode(){
    return value.hashCode() + this.iso4217code.hashCode();
}

In this class the value field is a BigDecimal and the iso4217code is a String. For what its worth the stackTrace finally dies in the BigDecimal hashCode() method, but I wouldn’t believe the BigDecimal hashCode() method would be broken.

Could someone please explain to me what I am missing about this hashCode() overriding? I know there must be something I’m doing wrong to generate this behaviour.

Here is the stack trace from my log file:

java.lang.StackOverflowError
    at java.math.BigDecimal.hashCode(BigDecimal.java:2674)
    at com.moremagic.util.MagicPrice.hashCode(Unknown Source)
    at com.moremagic.core.DuplicateCache2$Duplicate.hashCode(Unknown Source)
    at java.util.HashMap.get(HashMap.java:300)
    at com.moremagic.util.ExpirableHashMap.get(Unknown Source)
    at com.moremagic.core.DuplicateCache2.put(Unknown Source)
    at com.moremagic.core.DuplicateCache2.put(Unknown Source)
    at com.moremagic.core.DuplicateCache2.put(Unknown Source)
    at com.moremagic.core.DuplicateCache2.put(Unknown Source)
    <... and it continues with the put references for a looong time ...>

Also that trace references a proprietary get method so heres that for you:

public Object get(Object key) {
expire();
return hashtable.get(key);
}

expire() is a method that does time based removal of old entries in the table
hashtable is the HashMap object

Thanks!

Answer 1

With a StackOverflowError, it’s not important where the stack trace ends (that’s basically random, and may be completely unrelated to the problem), but what the repeating sequence before that is – and that should point out exactly what your problem is.

Your hashCode() methods look fine, they shouldn’t be able to cause a StackOverflowError.