Wanneer je equals() overschrijft om logische gelijkheid te definiëren, moet je ook hashCode() overschrijven — omdat op hash gebaseerde collecties (HashMap, ) vertrouwen op het contract dat . Dit breken leidt tot subtiele, moeilijk op te sporen bugs.
HashSet// by default, equals() compares IDENTITY (same object?), hashCode() is based on memory address
Person p1 = new Person("Ann", 30);
Person p2 = new Person("Ann", 30);
p1.equals(p2); // false by default — different objects, even with same data
Zonder overschrijving zijn twee objecten met identieke inhoud "niet gelijk" — meestal niet wat je wilt voor waardeobjecten.
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person p = (Person) o;
return age == p.age && Objects.equals(name, p.name); // compare by CONTENT
}
@Override
public int hashCode() {
return Objects.hash(name, age); // MUST be consistent with equals()
}
Het contract: als a.equals(b) waar is, dan moet a.hashCode() == b.hashCode() waar zijn.
Person p1 = new Person("Ann", 30);
Person p2 = new Person("Ann", 30); // equal by our equals()
Set<Person> set = new HashSet<>();
set.add(p1);
set.contains(p2); // ❌ likely FALSE — even though p1.equals(p2)!
Waarom? HashMap/HashSet gebruiken eerst hashCode() om de juiste bucket te vinden, vervolgens equals() daarbinnen. Met de standaard (identity-gebaseerde) hashCode(), belanden p1 en p2 in verschillende buckets, dus contains vergelijkt ze nooit — de set denkt dat ze anders zijn. Dit produceert verwarrende bugs: duplicaten in een Set, mislukte map-lookups, enzovoort.
1. equal objects → equal hash codes (REQUIRED for correctness)
2. unequal objects MAY have the same hash (collisions are allowed)
3. hashCode() must be consistent (same object → same code, unchanged)
4. equals() must be reflexive, symmetric, transitive, consistent
record Person(String name, int age) {} // records auto-generate equals/hashCode/toString!
Java records (en IDE-generatie / Lombok) produceren correcte, consistente equals/hashCode voor je.
Het equals/hashCode-contract is een van Java's belangrijkste — en meest geschonden — regels.
equals() overschrijven zonder hashCode() breekt op hash gebaseerde collecties op manieren die moeilijk op te sporen zijn: objecten die je als gelijk beschouwt raken "verloren" in HashMap/HashSet (mislukte lookups, spookduplicaten) omdat ze naar verschillende buckets hashen.
Aangezien deze collecties alomtegenwoordig zijn, moet elke waardeclass die als sleutel of set-element wordt gebruikt beide consistent overschrijven.
Begrepen waarom (het bucket-then-equals-opzoekingsmechanisme) — en het gebruik van records of gegenereerde code om het goed te doen — is essentieel voor correct gedrag en een klassiek interviewonderwerp dat echte kennis van hoe Java-collecties werken onthult.