equals() and hashCode()

Default equals() Behavior

By default, Object.equals() performs reference comparison (identity check).

public class DefaultEquals {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        
        // Default equals: compares references
        System.out.println(s1 == s2);          // false (different objects)
        System.out.println(s1.equals(s2));     // true (String overrides equals)
        
        // Custom class without override
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);
        System.out.println(p1.equals(p2));     // false! (reference comparison)
    }
}

class Person {
    String name;
    int age;
    
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // Uses Object.equals() - reference comparison
}

Why it matters:

• == checks reference equality
• equals() can be overridden for logical equality
• Most classes override equals() (String, Integer, collections)

Overriding equals() Correctly

The equals() contract requires five properties:

1. Reflexive: x.equals(x) must be true
2. Symmetric: x.equals(y) iff y.equals(x)
3. Transitive: x.equals(y) and y.equals(z) implies x.equals(z)
4. Consistent: Same result across multiple calls
5. Non-null: x.equals(null) must be false

public class Person {
    private String name;
    private int age;
    private String email;
    
    // Correct equals() implementation
    @Override
    public boolean equals(Object obj) {
        // 1. Check reference equality
        if (this == obj) return true;
        
        // 2. Check null and class
        if (obj == null || getClass() != obj.getClass()) return false;
        
        // 3. Cast
        Person other = (Person) obj;
        
        // 4. Compare fields
        return age == other.age
            && Objects.equals(name, other.name)
            && Objects.equals(email, other.email);
    }
    
    // MUST override hashCode() too!
    @Override
    public int hashCode() {
        return Objects.hash(name, age, email);
    }
}

Using IDE-generated equals(): Most IDEs (IntelliJ, Eclipse) can generate equals() and hashCode() methods for you.

hashCode() Contract

The contract has three rules:

1. Consistent: Same object must return same hash code across calls (unless fields used in hashCode change)
2. Equal objects must have equal hash codes: If x.equals(y) is true, then x.hashCode() == y.hashCode()
3. Unequal objects may have equal hash codes (hash collisions)

public class HashCodeExample {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);
        
        // Contract: equal objects → same hash code
        System.out.println(p1.equals(p2));         // true
        System.out.println(p1.hashCode() == p2.hashCode());  // MUST be true
        
        // Unequal objects can have same hash code
        Person p3 = new Person("Bob", 25);
        // p3.hashCode() might equal p1.hashCode() (collision)
        // but p1.equals(p3) is false
    }
}

// BAD hashCode() - always returns 1
class BadHashCode {
    @Override
    public int hashCode() { return 1; }  // Every object has same hash!
}

Why it matters: HashMap and HashSet use hash codes to find buckets. Bad hash codes degrade O(1) to O(n).

HashMap Behavior with Bad equals/hashCode

public class HashMapDemo {
    public static void main(String[] args) {
        // Bad: only overrides equals, not hashCode
        Map<Person, String> map = new HashMap<>();
        
        Person p1 = new Person("Alice", 30);
        map.put(p1, "Engineer");
        
        // This should work but WON'T with bad hashCode!
        Person p2 = new Person("Alice", 30);  // equal to p1
        System.out.println(map.get(p2));  // null! (different bucket)
        System.out.println(map.containsKey(p2));  // false!
    }
}

// Why it fails:
// 1. p1.hashCode() = some value → bucket A
// 2. p2.hashCode() = DIFFERENT value → bucket B
// 3. HashMap looks in bucket B, doesn't find p1
// 4. Returns null

HashMap's algorithm:

1. Compute key.hashCode()
2. Find bucket: hash & (n-1)
3. Search bucket for key using equals()

If hashCode() is wrong:

• Equal objects go to different buckets
• get(), containsKey(), remove() fail silently
• No error, just wrong results

Common equals/hashCode Mistakes

Mistake 1: Using mutable fields in hashCode

// BAD - field changes affect hashCode
public class MutablePerson {
    String name;
    int age;
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);  // age changes → different hash!
    }
}

Mistake 2: Forgetting null checks

// BAD - NPE if name is null
@Override
public boolean equals(Object obj) {
    Person other = (Person) obj;
    return this.name.equals(other.name);  // NPE!
}

// GOOD - use Objects.equals()
@Override
public boolean equals(Object obj) {
    Person other = (Person) obj;
    return Objects.equals(this.name, other.name);
}

Mistake 3: Wrong field types in equals

// BAD - compares all fields including ID
public boolean equals(Object obj) {
    return this.id == other.id
        && this.name.equals(other.name);  // Two people with same name are NOT equal
}

// GOOD - compare only meaningful fields
public boolean equals(Object obj) {
    return Objects.equals(this.name, other.name)
        && this.age == other.age;
}

Mistake 4: Not overriding both together

// ALWAYS override both equals() AND hashCode()
// Java contract requires it!

Rules to remember:

1. Always override both equals() and hashCode()
2. Use immutable fields in hashCode()
3. Use Objects.equals() for null-safe comparison
4. Include only fields that define equality