మీరు equals() అను logical equality నిర్వచించడానికి override చేసినప్పుడు, మీరు hashCode() కూడా override చేయాలి — ఎందుకంటే hash-based collections (HashMap, HashSet) contract పై ఆధారపడి ఉంటాయి, అంటే . ఇది breaking చేస్తే subtle, hard-to-find bugs ఏర్పడతాయి.
// 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
Override చేయకుండా, identical content తో two objects "not equal" ఉంటాయి — సాధారణంగా value objects కోసం మీరు కోరుకోని విషయం.
@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()
}
The contract: a.equals(b) true అయితే, అప్పుడు a.hashCode() == b.hashCode() తప్పనిసరిగా true ఉండాలి.
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)!
ఎందుకు? HashMap/HashSet మొదట hashCode() ని use చేసి సరైన bucket ను కనుగొనుతాయి, ఆపై దానిలో equals() ను use చేస్తాయి. డిఫాల్ట్ (identity-based) hashCode() తో, p1 మరియు p2 different buckets లోకి వెళ్లిపోతాయి, కాబట్టి contains వాటిని even compare చేయలేదు — set అవి different అని thinking చేస్తుంది. ఇది confusing bugs ను ఉత్పత్తి చేస్తుంది: Set లో duplicates, failed map lookups, 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 (మరియు IDE generation / Lombok) మీ కోసం correct, consistent equals/hashCode ఉత్పత్తి చేస్తాయి.
equals/hashCode contract Java లో అత్యంత ముఖ్యమైనదలలో ఒకటి — మరియు చాలా సాధారణంగా violated చేయబడుతుంది.
equals() ను hashCode() లేకుండా override చేయడం hash-based collections ను break చేస్తుంది, ఇది debug చేయడానికి hard way లో ఉంటుంది: మీరు equal సరిపోయిన objects HashMap/HashSet లో "lost" అవుతాయి (failed lookups, phantom duplicates) ఎందుకంటే అవి different buckets కు hash అవుతాయి.
ఈ collections ubiquitous ఉన్నందువల్ల, key లేదా set element గా use చేయబడే ప్రతిটి value-type class తప్పనిసరిగా both నిలకొలుపుకుండా override చేయాలి.
ఎందుకు (the bucket-then-equals lookup mechanism) అర్థం చేసుకోవడం — మరియు records లేదా generated code ను use చేసి సరిగ్గా get చేయడం — correct behavior కోసం essential మరియు Java collections ఎలా work చేస్తాయో real understanding ను reveal చేసే classic interview topic.