Equals & Hashcode

In Java, equals and hashCode are critical for the correct functioning of collections like HashMap. Here’s an overview of their roles and examples demonstrating various scenarios:

Role of equals and hashCode in HashMap

1. hashCode:

   • The hashCode method provides a hash code value for an object. When you insert an object into a HashMap, it calculates the hash code of the object to determine the bucket in which to place the entry. This hash code helps to quickly locate the object in the map.

2. equals:

   • The equals method checks if two objects are considered equal. When retrieving an object from a HashMap, the map first uses the hash code to find the correct bucket and then uses equals to find the exact object within that bucket.

Key Points

• If two objects are considered equal (equals returns true), their hashCode values must also be the same.

• If two objects have the same hashCode, it does not necessarily mean they are equal (hash collisions are possible).

Example Code

Here’s an example of how equals and hashCode are used in a HashMap:

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

class Person {

    String name;

    int age;

    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);

    }

}

public class HashMapExample {

    public static void main(String[] args) {

        Map<Person, String> map = new HashMap<>();

        Person p1 = new Person("Alice", 30);

        Person p2 = new Person("Alice", 30);

        Person p3 = new Person("Bob", 25);

        map.put(p1, "Engineer");

        map.put(p3, "Designer");

        System.out.println(map.get(p2)); // Output: Engineer

    }

}

Possible Scenarios

1. Correct Implementation

   • Scenario: Two objects that are considered equal must have the same hashCode.

   • Example: In the Person class above, p1 and p2 have the same name and age, so they are considered equal and have the same hashCode.

2. Equal Objects with Different hashCode

   • Scenario: This should be avoided. If equals is overridden but hashCode is not properly overridden, it can lead to incorrect behavior in HashMap.

Example:

@Override

public int hashCode() {

    return 1; // Same hashCode for all instances

}

2. • 
     

3. Different Objects with Same hashCode

   • Scenario: This is allowed and common due to hash collisions. HashMap will handle collisions by chaining entries in the same bucket.

   • Example: If two different Person objects end up with the same hashCode, they will still be differentiated by their equals method in the bucket.

4. Same hashCode but Different Objects

   • Scenario: When two objects have the same hashCode but are not equal, HashMap will use the equals method to differentiate them.

Example:

// Two Person objects with the same hashCode but different fields

Person p4 = new Person("Charlie", 30);

Person p5 = new Person("Alice", 35); // Different name, age

5. Unchanged hashCode for Mutability

   • Scenario: Objects used as keys in a HashMap should not change their hashCode once added. If an object's hash code changes while it's in the map, it can lead to data loss or retrieval issues.

Example:

// Mutable field in Person class

@Override

public int hashCode() {

    return Objects.hash(name, age); // Changes if `age` changes

}

Summary

• Implement hashCode to ensure consistent hashing and performance in HashMap.

• Implement equals to ensure proper equality checks.

• Maintain the contract that equal objects must have the same hashCode.

• Avoid changing an object's state that affects its hashCode while it is in the map.

Not Overriding equals or hashCode

1. When equals is Not Overridden

If equals is not overridden, the default implementation from the Object class is used. The default equals method in Object compares object references (i.e., checks if both references point to the same object in memory).

Implications for HashMap:

• Equality Check: HashMap relies on equals to determine if two keys are the same. If you don’t override equals, HashMap will use reference equality. This means that two different instances with the same data will not be considered equal unless they are the same instance.

Example:

import java.util.HashMap;

import java.util.Map;

class Person {

    String name;

    int age;

    Person(String name, int age) {

        this.name = name;

        this.age = age;

    }

}

public class HashMapExample {

    public static void main(String[] args) {

        Map<Person, String> map = new HashMap<>();

        Person p1 = new Person("Alice", 30);

        Person p2 = new Person("Alice", 30);

        map.put(p1, "Engineer");

        System.out.println(map.get(p2)); // Output: null

    }

}

Explanation: Since equals is not overridden, p1 and p2 are not considered equal despite having the same data, so map.get(p2) returns null.

2. When hashCode is Not Overridden

If hashCode is not overridden, the default implementation from the Object class is used. This default hashCode method generates a hash code based on the object's memory address.

Implications for HashMap:

• Hash Distribution: Objects will have different hash codes if they are different instances. This can affect the performance of HashMap if the default hash codes cause many collisions.

• Consistency with equals: If hashCode is not overridden, but equals is, or vice versa, it can lead to inconsistent behavior. HashMap relies on both methods to correctly store and retrieve entries.

Example:

import java.util.HashMap;

import java.util.Map;

class Person {

    String name;

    int age;

    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 && name.equals(person.name);

    }

}

public class HashMapExample {

    public static void main(String[] args) {

        Map<Person, String> map = new HashMap<>();

        Person p1 = new Person("Alice", 30);

        Person p2 = new Person("Alice", 30);

        map.put(p1, "Engineer");

        System.out.println(map.get(p2)); // Output: null

    }

}

Explanation: Even though equals is overridden to check for logical equality, p1 and p2 have different hash codes because hashCode is not overridden. Thus, HashMap cannot correctly find p2 using p1's hash code, and the output is null.

Summary

• Not Overriding equals: The default equals method uses reference equality. For HashMap, this means it only considers two keys equal if they are the exact same instance.

• Not Overriding hashCode: The default hashCode method uses the memory address. Without overriding it, HashMap may face performance issues due to ineffective hashing and potential collisions.

Best Practices:

• Always override both equals and hashCode when using custom objects as keys in a HashMap.

• Ensure that equals and hashCode are consistent with each other: if two objects are considered equal by equals, they must have the same hash code.