Why Does Overriding equals() Require Overriding hashCode() in Java?

etd_admin,

When working with Java, you might come across a situation where you override the equals() method in a class to define logical equality. But, did you know that overriding equals() requires overriding hashCode() as well? Ignoring this rule can lead to unexpected bugs, especially when your objects are used in hash-based collections like HashMap or HashSet.

This article explains why overriding equals() and hashCode() together is essential, with easy-to-follow examples. We’ll also highlight key concepts to help you better understand the inner workings of these methods.

The Contract Between equals() and hashCode()

The Java standard library imposes a strict contract on the relationship between equals() and hashCode():

  1. If two objects are equal (based on equals()), they must have the same hash code.
  2. If two objects have the same hash code, they may or may not be equal.

Failing to adhere to this contract can break the behavior of hash-based collections such as HashMap, HashSet, or HashTable.

Why is this Contract Important?

Hash-based collections use the hashCode() method to group objects into “buckets” for efficient access. If two objects are considered equal (based on equals()), they must belong to the same bucket. This is why their hash codes need to match.

If you override equals() without overriding hashCode(), the default implementation of hashCode() (inherited from Object) is used, which often produces inconsistent behavior.

Overriding equals() Without hashCode() Sample Code

Let’s look at an example to see what can go wrong:

import java.util.HashSet;
import java.util.Objects;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    // No hashCode() method implemented
}

public class Example {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);

        set.add(p1);
        set.add(p2); // Expected to replace p1, but it doesn’t!

        System.out.println(set.size()); // Output: 2
    }
}

In this example:

  • p1.equals(p2) returns true because they have the same name and age.
  • But since hashCode() is not overridden, p1 and p2 are placed in different hash buckets, resulting in a HashSet that mistakenly considers them as different objects.

Fix: Override Both equals() and hashCode()

To ensure consistent behavior, you must override both methods. Here’s the corrected version:

import java.util.HashSet;
import java.util.Objects;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age); // Consistent with equals()
    }
}

public class Example {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);

        set.add(p1);
        set.add(p2); // Now correctly replaces p1

        System.out.println(set.size()); // Output: 1
    }
}

Now:

  • p1 and p2 are treated as equal by both equals() and hashCode().
  • Both objects hash to the same bucket, ensuring correct behavior in the HashSet.

How to Implement equals() and hashCode() Correctly?

  1. Use the Objects class: Java provides the Objects.equals() and Objects.hash() methods to simplify implementation.
  2. Follow the contract: Ensure that if two objects are equal, they return the same hash code.
  3. Test your implementation: Use unit tests to verify that your equals() and hashCode() methods are consistent.

Why Does Overriding equals() Require Overriding hashCode()?

To summarize, overriding equals() requires overriding hashCode() because:

  1. Hash-based collections rely on consistent hashCode() values to group and retrieve objects.
  2. Violating the contract between equals() and hashCode() leads to bugs, such as duplicate entries in a HashSet or failing to retrieve a key from a HashMap.

When overriding equals in Java, always ensure you provide a matching hashCode() implementation. This simple step will save you from subtle bugs in your code.

Overriding equals in Java without also overriding hashCode can cause unexpected behavior in hash-based collections. To avoid issues, always ensure your equals() and hashCode() methods are consistent and adhere to their contract. Following best practices like using the Objects utility class makes this task easier and your code more reliable.

Java