Cén fáth ar cheart duit equals() agus hashCode() a shárscríobh le chéile?

Question

Accepted Answer

Nuair a shárscríobhann tú `equals()` chun comhionannas loighiciúil a shainiú, **ní mór** duit `hashCode()` a shárscríobh freisin — toisc go bhíonn bailiúcháin bhunaithe ar hash (`HashMap`, `HashSet`) ag brath ar an chonradh go **bhfuil códanna hash cothrom ag rudaí comhionanna**. Má bhrisann tú seo, beidh fabhtanna doilbhéartacha agus deacair a fháil ann. ## An iompar réamhshocraithe ```java // 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 ``` Gan shárscríobh, ní bhíonn dhá réad le ábhar comhionann "comhionann" — go minic ní sin an rud ba bhreá leat do rudaí luacha. ## equals() a shárscríobh chun comhionannas loighiciúil ```java @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 } ``` ## An riail chriticiúil: hashCode() a shárscríobh freisin ```java @Override public int hashCode() { return Objects.hash(name, age); // MUST be consistent with equals() } ``` **An conradh:** má tá `a.equals(b)` fíor, ansin **caithfidh** `a.hashCode() == b.hashCode()` a bheith fíor. ## Cad a bhriseas má shárscríobhann tú equals() ach nach bhfuil hashCode() á shárscríobh ```java Person p1 = new Person("Ann", 30); Person p2 = new Person("Ann", 30); // equal by our equals() Set set = new HashSet<>(); set.add(p1); set.contains(p2); // ❌ likely FALSE — even though p1.equals(p2)! ``` Cén fáth? Úsáideann HashMap/HashSet `hashCode()` ar dtús chun an bhoccat ceart a aimsiú, ansin `equals()` laistigh de. Leis an réamhshocrú (samhailte-bhunaithe) `hashCode()`, tuirlingíonn `p1` agus `p2` i **bhoccaí dhifriúla**, mar sin ní dhéanann `contains` comparáid a dhéanamh eatarthu riamh — cheapann an tacar go bhfuil siad difriúil. Táirgeann sé seo fabhtanna dritháireach: dúbailíochtaí i Tacar, cuardachtaí mapaí dochloíte, srl. ## Rialacha an chonrtha ```text 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 ``` ## Aicearrigh nua-aimseartha ```java record Person(String name, int age) {} // records auto-generate equals/hashCode/toString! ``` Táirgeann **taifead** Java (agus giniúint IDE / Lombok) `equals`/`hashCode` cearta, comhsheasmhach ar do shon. ## Cén fáth a bhíonn tábhacht ann Is í an chonradh equals/hashCode ceann de na rialacha is tábhachtaí — agus is minic a bhionn siad i nganntanas — i Java. Bhí `equals()` á shárscríobh gan `hashCode()` a bhriseas bailiúcháin bhunaithe ar hash ar bhealai atha deacair a dhíchealadh: fágann rudaí a cheapann tú a bheith comhionann "caillte" i `HashMap`/`HashSet` (cuardachtaí dochloíte, dúbailíochtaí phantóm) toisc go bhfuil siad i dhifferáil go bocca dhifriúla. ">Toisc go bhfuil na bailiúcháin seo ó bhreithiúnacht, caithfidh gach aicme cineál-luacha a úsáidtear mar eochair nó eilimint tacar **an dá ceann** a shárscríobh go comhsheasmhach. Tuiscint ar **cén fáth** (an méacharachán cuardaigh boccat-ansin-comhionannais) — agus taifead nó cód ginte a úsáid chun é a dhéanamh i gceart — is gá don iompar ceart agus ábhar agallamh clasaiceach a nochtann fíor-thuiscint ar an gcaoi a n-oibríonn bailiúcháin Java.