How Does Caching HashCode Work in Java According to Joshua Bloch in Effective Java?

What is the concept of caching hashCode in Java as per Joshua Bloch's Effective Java?

public class Example {
    private final int cachedHashCode;

    public Example() {
        this.cachedHashCode = computeHashCode();
    }

    @Override
    public int hashCode() {
        return cachedHashCode;
    }
    
    private int computeHashCode() {
        // Complex computation logic
        return 42; // Example placeholder
    }
}

Caching the hashCode in Java is an optimization technique recommended by Joshua Bloch in his book Effective Java. This technique involves storing the result of the hashCode computation in a variable, especially for immutable objects, to avoid recalculating it each time the hashCode is called.

public class ImmutableCircle {
    private final double radius;
    private final int cachedHashCode;

    public ImmutableCircle(double radius) {
        this.radius = radius;
        this.cachedHashCode = calculateHashCode();
    }

    @Override
    public int hashCode() {
        return cachedHashCode;
    }

    private int calculateHashCode() {
        return Double.valueOf(radius).hashCode();
    }
}

Causes

• To improve performance when using objects in hash-based collections like HashMap and HashSet.
• To avoid computational overhead for classes whose hash code is expensive to compute.

Solutions

• Implement the caching mechanism by using a private final variable to store the hash code.
• Initialize this variable in the constructor of the class to avoid redundancy in hash code calculations.

Mistake: Forgetting to override equals() when overriding hashCode().

Solution: Always ensure that if you override hashCode(), you also override equals() to maintain the contract between them.

Mistake: Using mutable fields in hashCode computation for mutable objects.

Solution: Prefer immutable fields in hashCode and equals to maintain consistency and integrity.