Stuck in HashMap + equals() behaviour

Question

I am studying the SCJP 6, and got stuck in one example from the book.
package map583;
import java.util.*;
public class Dog {
    public Dog(String n) {
        name = n;
    public String name;
    public boolean equals(Object o) {
        if(o instanceof Dog){
            Dog dog = (Dog) o;
            if(dog.name.equalsIgnoreCase(this.name)){
                return true;
            }else{
                return false;
        } else {
            return false;
    public int hashCode() {
        return name.length();
package map583;
import java.util.*;
public class MapTest {
    public static void main(String[] args) {
        Map<Object, Object> m = new HashMap<Object, Object>();
        Dog d1 = new Dog("clover");
        m.put(d1, "Dog key");
        d1.name = "123456";
        System.out.println(m.get(d1));
}The output is "Dog Key", what I question is when changing d1.name to "123456", hashcode() returns same value, BUT equals() method compares to String values, obviously the Dog object name value in HashMap is "clover", but the d1.name value is "123456", and they are not the same.
This gives me another assumption. Is the changing of name to "123456" actually changes the dog object name value in the HashMap? Because the dog object stored in the HashMap is d1. But when I changed the code to :
        d1.name = "1234567890";
        System.out.println(m.get(d1));It outputs null now. So it proves that the dog object stored in the HashMap CANNOT be changed by changing d1.name value, so how to explain my first question?

Answer 1

roamer wrote:
Now same question again, then how to explain this?
d1.name = "1234567890";
System.out.println(m.get(d1));   // returns "null". #2the key in the HashMap stores the variable name d1, which points to the Dog object modified by the above statement, which name is "1234567890" now. So when searching the HashMap, the argument passed (d1) is actually referencing the SAME object as the variable in the HashMap (which is also d1), same hashcode AND returns true in equals() method.
So what the hell why this statment fails but #1 succeeded. When thinking in the same logic flow.Okay, you are REALLY missing the point here. We never get to the equals check because the hashCode is different, so it doesn't matter if it's the same object. This is what I tried to explain to you earlier: The messed up hash code might make you not even have a chanceto compare the object. With this very simple hashCode, changing the name to a different one of the same length didn't alter the hashCode, but changing it to a different length did, so we searched the wrong bucket, and therefore never had a chance to find the object.
Dog d1 = new Dog("clover"); // A
m.put(d1, "Dog key"); // B
System.out.println(m.get(d1)); // C   // returns "Dog key". ---- Yes, it is normal.
d1.name = "123456"; // D
System.out.println(m.get(d1)); // E   // returns "Dog key". #1
d1.name = "1234567890"; // F
System.out.println(m.get(d1)); // G   // returns "null". #2A: Create an instance of Dog. name = "clover", stick a reference to it in variable d1
B. Put a an entry in the map where the key is that Dog and the value is "Dog Key". The reference to the key is stored in the bucket for hashCode=6
C. Search for d1 in the map. This means 1) Get hashCode of object pointed to by d1 (6). 2) Find that bucket. 3) For each element in that bucket, check if it equals(d1) 4. When we find the Dog in that bucket that equals(d1) because its name equals(d1.name), we return the corresponding value: "Dog key"
D. Set the name of the only Dog object we've created to "123456". This does not change its bucket in the map, because hashCode() uses name.length(), which is still 6.
E. Same as C, except now we're loooking for name of "123456" instead of "clover"
F. Set the Dog object's name to "1234567890". This changes its hashcode, so it is (probably) no longer in the same bucket.
G. Search for d1 in the map. This means 1) Get hashCode of object pointed to by d1 (10). 2) Find that bucket. 3) For each element in that bucket, check if it equals(d1) 4. Since it's a different bucket, it doesn't matter if equals() is true, or even if == is true. The object is not found because we searched the wrong bucket.
Note also what would happen if we had two different Dog objects. If we change the one in the map from "clover" to "123456", we'll still search the same bucket, but we won't return anything because d1 is a different object and "clover".equals("123456") is false. The second case would still return null for the same reason it currently does--we'd never even get to search the right bucket.
Edited by: jverd on Feb 2, 2010 7:34 PM