आपको equals() और hashCode() को एक साथ क्यों override करना चाहिए?

Question

Accepted Answer

जब आप logical equality परिभाषित करने के लिए `equals()` को override करते हैं, तो आपको `hashCode()` को भी **अवश्य** override करना चाहिए — क्योंकि hash-based collections (`HashMap`, `HashSet`) इस contract पर निर्भर करते हैं कि **equal objects के equal hash codes हों**। इसे तोड़ने से सूक्ष्म, खोजने में कठिन bugs उत्पन्न होते हैं। ## default behavior ```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 ``` bina override किए, समान content वाले दो objects "equal नहीं" होते — आमतौर पर value objects के लिए यह वह नहीं होता जो आप चाहते हैं। ## logical equality के लिए equals() को override करना ```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 } ``` ## महत्वपूर्ण नियम: hashCode() को भी override करें ```java @Override public int hashCode() { return Objects.hash(name, age); // MUST be consistent with equals() } ``` **contract:** यदि `a.equals(b)` true है, तो `a.hashCode() == b.hashCode()` true होना **अवश्य** चाहिए। ## यदि आप equals() को override करते हैं लेकिन hashCode() को नहीं, तो क्या टूटता है ```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)! ``` क्यों? HashMap/HashSet पहले सही **bucket** खोजने के लिए `hashCode()` का उपयोग करते हैं, फिर उसके भीतर `equals()` का। default (identity-based) `hashCode()` के साथ, `p1` और `p2` *अलग-अलग* buckets में आते हैं, इसलिए `contains` उनकी तुलना ही कभी नहीं करता — set उन्हें अलग समझता है। यह हैरान करने वाले bugs उत्पन्न करता है: Set में duplicates, असफल map lookups, आदि। ## contract नियम ```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 ``` ## आधुनिक shortcut ```java record Person(String name, int age) {} // records auto-generate equals/hashCode/toString! ``` Java **records** (और IDE generation / Lombok) आपके लिए सही, consistent `equals`/`hashCode` उत्पन्न करते हैं। ## यह क्यों महत्वपूर्ण है equals/hashCode contract Java के सबसे महत्वपूर्ण — और सबसे आम तौर पर उल्लंघन किए जाने वाले — नियमों में से एक है। `hashCode()` के बिना `equals()` को override करना hash-based collections को ऐसे तरीकों से तोड़ता है जिन्हें debug करना कठिन है: जिन objects को आप equal मानते हैं वे `HashMap`/`HashSet` में "खो" जाते हैं (असफल lookups, phantom duplicates) क्योंकि वे अलग-अलग buckets में hash होते हैं। चूंकि ये collections सर्वव्यापी हैं, key या set element के रूप में उपयोग की जाने वाली प्रत्येक value-type class को **दोनों** को consistent रूप से override करना चाहिए। *क्यों* को समझना (bucket-फिर-equals lookup mechanism) — और इसे सही करने के लिए records या generated code का उपयोग करना — सही behavior के लिए आवश्यक है और एक classic interview विषय है जो Java collections कैसे काम करती हैं इसकी वास्तविक समझ प्रकट करता है।