HashMap and hashCode/equals question

[Nico Van Brandt]

Hi everybody,

I'm learning for the SCJP but while I'm reaching the end of the book, I think I'm starting to get confused and maybe I'm mixing things up...
So my question is the following; Why is it that for the first System.out it won't check the .equals implementation and for the second, it does call .equals?
Does the containsKey method look for == prior looking at .equals or am I just going crazy?

Thanks in advance,

Nico

import java.util.HashMap;
import java.util.Map;

public class Main{
	
	public static void main(String[] args){
		
		Map<Person, String> map = new HashMap<Person, String>();
		
		Person nicolas = new Person("Nicolas");
		nicolas.setSSN("154-58-4558");
		
		map.put(nicolas, nicolas.getSSN());
		
		System.out.println(map.containsKey(nicolas)); // Does not call.equals and prints true
		
		System.out.println(map.containsKey(new Person("Nicolas"))); // Calls .equals and prints false
				
	}
	
}

class Person {
	
	private String name;
	private String ssn;
	
	Person(String name){
		this.name = name;
	}
	
	public boolean equals(Object o){
		return false;
	}

	public int hashCode(){
		return name.length();
	}

	// Getter and Setter stuff...	
	
}

[Sebastian Janisch]

I'm not 100% sure but i would guess that the containsKey method first invokes == and then equals, since == is the quicker comparison and the contract says that when obj1 == obj2 then obj1.equals(obj2) must return true;

[Rob Spoor]

If you check your JDK folder, you'll see a "src.zip" file. Inside you'll find the source code for most of the core API classes. HashMap is one of those.

Below is the code of containsKey and a method it uses. You'll see that it indeed uses == on line 25:

    /**
     * Returns <tt>true</tt> if this map contains a mapping for the
     * specified key.
     *
     * @param   key   The key whose presence in this map is to be tested
     * @return <tt>true</tt> if this map contains a mapping for the specified
     * key.
     */
    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    /**
     * Returns the entry associated with the specified key in the
     * HashMap.  Returns null if the HashMap contains no mapping
     * for the key.
     */
    final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

This is probably done to speed things up, but I think it shouldn't be there.