When Equals and HashCodes Misbehave

TL;DR: Misaligned equals() and hashCode() break collections.

Problems

• The least surprise principle violation
• Contract violations
• Mutable key issues
• Duplicate hash codes
• Debugging becomes hard
• Poor hash distribution

Solutions

1. Avoid mutable keys
2. Use effective hashes
3. Test behavior carefully
4. Avoid redefining equal and hash
5. Honor the Bijection

Context

When you work with hashed collections like HashMap or HashSet, you should pay special attention to equals() and hashCode().

A mismatch or poor implementation can lead to unpredictable bugs.

equals() method defines logical equality, while hashCode() determines an object’s bucket for faster access.

When these two methods fail to align, collections lose their reliability, leading to poor performance or issues like duplicate entries caused by hash collections.

The best solution is never to override the hash and equals and rely on object identity.

This is what happens in the real world using the MAPPER).

Whenever you get an external object you need to map it to your bijection correspondence and not create a brand new one.

Once within your controlled system, rely on identity and forget equality issues.

Sample Code

Wrong

class BrokenObject {
    private int value;

    public BrokenObject(int value) {
        this.value = value;
    }

    @Override
    public boolean equals(Object obj) {
        return true; // Always equal
    }

    @Override
    public int hashCode() {
        return super.hashCode(); // Uses default implementation
    }
}

Right

class FixedObject {
    private final int value;

    public FixedObject(int value) {
        this.value = value;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        FixedObject that = (FixedObject) obj;
        return value == that.value;
    }

    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}

// This is the best solution

class CleanObject {
    private final int value;

    public FixedObject(int value) {
        this.value = value;
    }

    // - @Override
    // - public boolean equals(Object obj) {}

    // - @Override
    // - public int hashCode() { 
    }
}

Detection

[X] Semi-Automatic

Automated linters and IDEs flag issues when you don't properly override equals() or hashCode().

Tags

• Premature Optimization

Level

[x] Intermediate

AI Generation

AI-generated code often missteps when generating equals() and hashCode(), especially for mutable objects.

AI Detection

AI tools can help fix this smell with minimal guidance.

Try Them!

Remember: AI Assistants make lots of mistakes

Conclusion

When you misuse equals() or hashCode(), collections misbehave.

Stick to their contracts, use effective hashes, and avoid mutable keys.

Relations

Code Smell 150 - Equal Comparison

Maxi Contieri ・ Jul 19 '22

#javascript #webdev #beginners #programming

Code Smell 167 - Hashing Comparison

Maxi Contieri ・ Oct 9 '22

#webdev #programming #java #blockchain

Code Smell 49 - Caches

Maxi Contieri ・ Dec 11 '20

#oop #webdev #codenewbie #caching

More Info

The evil powers of mutants

Maxi Contieri ・ Dec 19 '20

#webdev #programming #mutation #oop

Disclaimer

Code Smells are my opinion.

Credits

Photo by frank mckenna on Unsplash

“Bad programmers worry about the code. Good programmers worry about data structures and their relationships.”

Linus Torvalds

Software Engineering Great Quotes

Maxi Contieri ・ Dec 28 '20

#codenewbie #programming #quotes #software

This article is part of the CodeSmell Series.

How to Find the Stinky parts of your Code

Maxi Contieri ・ May 21 '21

#codenewbie #tutorial #codequality #beginners