The equals() and hashCode() methods must be rewrite correctly at the same time, otherwise the hash set (such as HashMap and HashSet) will be invalid; 2. equals() is used to define the logical equality of objects, and the actual field values need to be compared instead of references; 3. hashCode() returns the object hash code, and it is necessary to ensure that equal objects have the same hash value; 4. Violating the contract will make it impossible to find the stored object from the collection, because hash search first uses hashCode() to locate the bucket, and then uses equals() to confirm the match; 5. It is recommended to use Objects.equals() and Objects.hash() to implement null safe and consistent logic, and avoid object fields used as keys being modified.

The equals() and hashCode() methods in Java are fundamental for object comparison and are especially important when working with collections like HashMap , HashSet , and Hashtable . Here's how they work—and why they must be used together correctly.

? What equals() Does

The equals(Object obj) method checks whether two objects are logically "the same." By default (from Object class), it compares memory addresses (like == ), but it's meant to be overridden to define what "sameness" means for your class.

Example:

 public class Person {
    private String name;
    private int age;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Person)) return false;
        Person other = (Person) obj;
        return age == other.age && Objects.equals(name, other.name);
    }
}

This version compares actual data—not just references.

? What hashCode() Does

The hashCode() method returns an integer that acts as a "fingerprint" for the object. It's used by hash-based collections to quickly locate buckets where objects are stored.

By default, it returns a unique int per object (often based on memory address), but if you override equals() , you must also override hashCode() , or collections will break.

Why?
Because of the hash contract :

If two objects are equal according to equals() , they must have the same hashCode() .

Example:

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

This ensures that equal Person objects produce the same hash code—so they end up in the same bucket in a HashMap .

?? What Happens If You Don't Override Both?

• If you override equals() but not hashCode() :

  • Two logically equal objects might have different hash codes.
  • In a HashSet , both could be added—even though they're "equal."
  • In a HashMap , you might not find a key you put in, because the lookup uses hashCode() first.

• If you override hashCode() but not equals() :

  • Objects might have same hash code but still be unequal.
  • That's fine (hash collisions are normal), but equality still relies on reference comparison—which is probably not what you want.

? Best Practices

• Always override both together.
• Use Objects.equals() and Objects.hash() for null-safe implementations.
• Make sure hashCode() only uses fields that equals() uses.
• Keep both methods consistent: if fields used in equals() change, the behavior of collections may become unpredictable (so avoid mutating key objects in maps!).

? Pro Tip

Use your IDE or tools like Lombok ( @EqualsAndHashCode ) to generate these methods—it's easy to miss edge cases (like nulls or inheritance).

In short:
equals() defines logical equality.
hashCode() enables fast lookup in hash-based collections.
Break the contract between them, and your collections won't work as expected.

That's it—simple but critical.

The above is the detailed content of How the Java `equals()` and `hashCode()` Methods Work. For more information, please follow other related articles on the PHP Chinese website!