equals() and hashCode()

The equals() and hashCode() contract governs object comparison and hash-based collections in Java. Violating this contract causes silent data corruption in HashMap and HashSet.

The Equivalence Contract

An implementation of equals() must satisfy five equivalence properties:

• Reflexive: x.equals(x) must return true.
• Symmetric: If x.equals(y) is true, then y.equals(x) must return true.
• Transitive: If x.equals(y) is true and y.equals(z) is true, then x.equals(z) must return true.
• Consistent: Repeated invocations of equals() must return the same result, provided no information used in comparison is modified.
• Null-Comparison: x.equals(null) must return false for any non-null reference x.

Hash Collisions and HashMap Bucket Resolutions

When you put an object in a HashMap, the map uses the object's hashCode() to calculate which bucket index to store the entry in.

Hash Collision: Occurs when two unequal objects return the same hashcode. They resolve to the same bucket index:

• Chaining: The bucket stores colliding elements in a linked list. Lookup costs degrade from O(1) to O(N).
• Treeification (Java 8+): If a bucket's collision list exceeds a threshold (8 elements) and the map's total capacity is at least 64, the JVM converts the list into a self-balancing Red-Black Tree, improving lookup costs to O(log N).

Common Pitfalls

• Overriding equals without hashCode: The classic error. Objects are added to the map but cannot be found during lookups because they search different buckets.
• Using mutable fields in hashcodes: Modifying fields that are used to compute the hashCode after the object has been added to a Map. The object's bucket index changes, making it lost inside the map.
• Incorrect Parameter Type: Writing public boolean equals(User other) instead of overriding public boolean equals(Object other), which overloads the method instead of overriding it.

Best Practices

• Always override hashCode() whenever you override equals(). Use the same fields for both calculations.
• Use Objects.equals(a, b) and Objects.hash(fields...) to write clean, null-safe overrides.
• Use immutable fields (like IDs) for equals and hashCode calculations. Avoid using mutable fields to prevent runtime lookup failures.

Interview-Relevant Information