Hashmap containsKey() method does not appear to work

Question

Hashmap containsKey() method does not appear to work
I have an amazingly simple custom class called CalculationKey, with my own amazingly simple custom equals() method. For some reason when I call my containsKey() method on my HashMap it does not use my defined equals method in my defined key class. Do hashmaps have their own tricky way for establishing whether two keys are equal or not?
THIS IS MY AMAZINGLY SIMPLE CUSTOM KEY CLASS
private class CalculationKey
private LongIdentifier repID;
private LongIdentifier calcID;
public CalculationKey(LongIdentifier repID, LongIdentifier calcID)
this.repID = repID;
this.calcID = calcID;
public boolean equals(Object o)
CalculationKey key = (CalculationKey)o;
if (key.getCalcID().equals(calcID) &&
key.getRepID().equals(repID))
return true;
else
return false;
public LongIdentifier getCalcID()
return calcID;
public LongIdentifier getRepID()
return repID;
THIS IS MY AMAZINGLY SIMPLE CALLS TO MY HASHMAP WHICH ADDS, CHECKS, AND GETS FROM THE HASHMAP.
private Hashmap calculationResults = new Hashmap();
public boolean containsCalculationResult(LongIdentifier repID, LongIdentifier calcID)
if (calculationResults.containsKey(new CalculationKey(repID, calcID)))
return true;
else
return false;
public Double getCalculationResult(LongIdentifier repID, LongIdentifier calcID)
return (Double)calculationResults.get(new CalculationKey(repID, calcID));
public void addCalculationResult(LongIdentifier repID, LongIdentifier calcID, Double value)
calculationResults.put(new CalculationKey(repID, calcID), value);
}....cheers

Answer 1

You can make a trivial implementation to return a
constant (not recommended)What do you mean by that? Hmm.. I guess you mean that
you shouldn't use the same constant for all objects?
But don't see the int value of an (immutable) Integer
as constant?
/Kaj
You can write hashCode to just always return, say, 42. It will be correct because all objects that are equal will have equal hashcodes. Objects that are not equal will also have equal hashcodes, but that's legal--it just causes a performance hit.
The value is that it's really really simple to implement: public int hashCode() {
    return 42;
} So you can use it temporarily while you're concentrating on learning other stuff, or during debugging as a way to confirm that the hashCode is not the problem. (Returning a constant from hashcode(), rather than computing a value, is always legal and correct, so if something's behaving wrong, and you replace your hashCode method with the one above, and it still breaks, you know hashCode isn't the problem.)
The downside is that you're defeating the purpose of hashing, and any non-trival sized map or set is going to have lousy performance.
For a decent hashCode recipe, look here:
http://developer.java.sun.com/developer/Books/effectivejava/Chapter3.pdf