Correctness of the HashMap implementation w.r.t. its specifications/docs

Question

According to the JavaDoc of HashMap, containsKey is defined as :
public boolean containsKey(Object key)
     Returns true if this map contains a mapping for the specified key.
     Specified by:
          containsKey in interface Map
     Overrides:
          containsKey in class AbstractMap
     Parameters:
          key - The key whose presence in this map is to be tested
     Returns:
          true if this map contains a mapping for the specified key.
Again, according to the JavaDoc of Map, containsKey is defined as :
public boolean containsKey(Object key)
Returns true if this map contains a mapping for the specified key. More formally, returns true if and only if this map contains at a mapping for a key k such that (key==null ? k==null : key.equals(k)). (There can be at most one such mapping.)
In a project, I use a HashMap to store objects and my key class is something like that :
public class MyKey {
private String s1 = null;
private String s2 = null;
public MyKey(String s1, String s2) {
this.s1 = s1;
this.s2 = s2;
public boolean equals(Object o) {
if (o instanceof MyKey) {
MyKey oKey = (MyKey) o;
returns this.s1.equals(o.s1) && this.s2.equals(o.s2);
returns false;
So according to the JavaDoc, the following should be ok :
MyKey key1 = new MyKey("hello","world");
MyKey key2 = new MyKey("hello","world");
HashMap map = new HashMap();
map.put(key1, new Object());
map.containsKey(key1); // returns true
map.containsKey(key2); // returns false BUT should return true
After reading the code of containsKey, it actually does a AND test on a hashcode and the equals method, which does not correspond to the spec.
map.containsKey(key2) returns false because although key1.equals(key2) is true, key1.hashCode() != key2.hashCode().
Is that behaviour normal ? Am I missing something in my understanding of the keys comparison ?
This behaviour also stands for the Set Interface, despite what's said in the JavaDoc.
Regards.
Jerome

Answer 1

It's not so clear exactly how the documentation should be ammended though. HashMap.containsKey is required to conform to Map.containsKey, and putting the hashCode referencing stuff into Map would force its use in every Map implementation, even if they weren't in fact hash maps.
I think the view that the designers have taken is that the key is assumed to be well-formed, which means that all its methods obey their contracts. If this isn't true, then the behaviour is undefined.
Do we want such a well-formed requirement to be expressly stated everywhere that an Object is used?
Sylvia.