När du åsidosätter equals() för att definiera logisk likhet, måste du också åsidosätta hashCode() — eftersom hash-baserade samlingar (HashMap, ) förlitar sig på kontraktet att . Om du bryter detta leder det till subtila, svåra att hitta buggar.
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
Utom om du åsidosätter, är två objekt med identiskt innehål "inte lika" — vanligtvis inte vad du vill för värdeobjekt.
@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()
}
Kontraktet: om a.equals(b) är sant, måste a.hashCode() == b.hashCode() också vara sant.
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)!
Varför? HashMap/HashSet använder först hashCode() för att hitta rätt bucket, sedan equals() inom den. Med standardimplementationen (identitetsbaserad) hashCode(), hamnar p1 och p2 i olika buckets, så contains jämför dem aldrig — mängden tror att de är olika. Detta producerar förvirrande buggar: dubbletter i en Set, misslyckade mappsökningar, etc.
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 (och IDE-generering / Lombok) producerar korrekta, konsekventa equals/hashCode för dig.
Equals/hashCode-kontraktet är en av Javas viktigaste — och mest ofta brustande — regler.
Att åsidosätta equals() utan hashCode() bryter hash-baserade samlingar på sätt som är svåra att felsöka: objekt som du anser lika blir "försvunna" i HashMap/HashSet (misslyckade sökningar, fantomfördubblingar) eftersom de hashas till olika buckets.
Since dessa samlingar är allmänt förekommande, måste varje värdetype-klass som används som nyckel eller mängdelement åsidosätta båda konsekvent.
Att förstå varför (bucket-sedan-equals-uppslagningsmekanismen) — och att använda records eller genererad kod för att få det rätt — är väsentligt för korrekt beteende och ett klassiskt intervjuämne som avslöjar verklig förståelse för hur Javas samlingar fungerar.