Java equals() and hashcode() for interviews

The basic implementation of the equals() method in Java is provided by the Object class, which is the superclass of all Java classes. Its implementation is as follows:

public boolean equals(Object obj) {
    return (this == obj);
}

Explanation

The default equals() method uses the == operator to compare the memory addresses of the objects, not their contents or attributes.
This means two objects are considered equal only if they are the same instance in memory.

Why It Is Not Advised to Use the Default Implementation

The default implementation is often inadequate because:

Content Comparison is Usually Needed: In most cases, you want to compare the content or state of objects (e.g., fields/attributes) rather than their memory addresses. For instance:
- Comparing two String objects.
- Comparing two Person objects with the same name and ID.
Leads to Unexpected Behavior: Without overriding equals(), two logically equivalent objects might not be treated as equal, causing bugs, especially in collections like HashMap or HashSet that rely on equals().
Breaks Contract with Other Methods: If equals() isn't properly overridden, it can lead to violations of its contract with other Java methods and classes, like hashCode() or collection operations.

When using objects as keys in HashMap, Hashtable, or any other data structure that relies on hashing, correctly implementing the equals() and hashCode() methods is critical. Here's why:

The Role of `hashCode()`:

hashCode() is used to compute an integer value (hash code) that determines the bucket in which the key-value pair should be stored.
Contract: According to the hashCode() contract, if two objects are considered equal according to their equals() method, they must return the same hashCode().
- If two objects are unequal, they may have different hash codes, but it is not mandatory (though having different hash codes improves performance).

The Role of `equals()`:

equals() is used to compare the contents of two objects.
When retrieving data, if two keys have the same hash code, HashMap will use the equals() method to compare keys and ensure it retrieves the correct value.

Key Points for Correct `equals()` and `hashCode()` Implementations:

If you override equals(), you must also override hashCode().
Failing to do so can lead to incorrect behavior when keys are stored in a HashMap (e.g., keys that are "equal" might not be found in lookups if their hash codes differ).

Example: Custom Key Class

Here’s a simple example to illustrate how to correctly override equals() and hashCode():

Without Proper Overrides:

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

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

Map<Person, String> map = new HashMap<>();
Person p1 = new Person("Alice", 30);
Person p2 = new Person("Alice", 30);

map.put(p1, "Person 1");
System.out.println(map.get(p2));  
// Output: null (p1 and p2 are considered different keys)

With Proper Overrides:

public 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 obj) {
        if (this == obj) return true;  // Same object reference
        if (obj == null || getClass() != obj.getClass()) return false;  // Class check
        Person person = (Person) obj;

          // Compare fields
        return age == person.age && name.equals(person.name);
    }

    @Override
    public int hashCode() {
      // Generate hash code using fields
        return Objects.hash(name, age);
    }
}

Map<Person, String> map = new HashMap<>();
Person p1 = new Person("Alice", 30);
Person p2 = new Person("Alice", 30);

map.put(p1, "Person 1");
System.out.println(map.get(p2));  
// Output: "Person 1" (p1 and p2 are considered equal keys)

Explanation:

equals() Method: Compares the values of the name and age fields to determine equality.
hashCode() Method: Generates a consistent hash code based on the values of name and age. This ensures that if two objects are equal, they will produce the same hash code.

Key Points to Remember:

Consistency Between equals() and hashCode(): Always ensure objects that are "equal" according to equals() return the same hashCode().
Efficient hashCode() Generation: Use fields that are meaningful to uniquely identify objects. You can use Objects.hash() (introduced in Java 7) for a convenient and effective hash code calculation.
Collisions Are Unavoidable: Even with a good hashCode() implementation, collisions can occur. Proper equals() handling ensures accurate retrieval and updates.

Java equals() and hashcode()