logical equality-ஐ வரையறுக்க நீங்கள் equals()-ஐ override செய்யும்போது, நீங்கள் hashCode()-ஐயும் கட்டாயம் override செய்ய வேண்டும் — ஏனெனில் hash-அடிப்படையிலான collections (, ) என்ற contract-ஐ நம்பியுள்ளன. இதை உடைப்பது நுட்பமான, கண்டுபிடிக்க கடினமான bugs-க்கு வழிவகுக்கிறது.
HashMapHashSet// 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 செய்யாமல், ஒரே மாதிரியான உள்ளடக்கம் கொண்ட இரண்டு objects "சமமாக இல்லை" — பொதுவாக 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()
}
Contract: a.equals(b) உண்மை எனில், அப்போது a.hashCode() == b.hashCode() உண்மையாக இருக்க வேண்டும்.
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 முதலில் சரியான bucket-ஐ கண்டறிய hashCode()-ஐ பயன்படுத்துகின்றன, பின்னர் அதனுள் equals()-ஐ பயன்படுத்துகின்றன. இயல்புநிலை (identity-அடிப்படையிலான) hashCode() உடன், p1 மற்றும் p2 வெவ்வேறு buckets-இல் தரையிறங்குகின்றன, எனவே contains அவற்றை ஒருபோதும் ஒப்பிடுவதில்லை — set அவற்றை வேறுபட்டதாக நினைக்கிறது. இது குழப்பமான bugs-ஐ உருவாக்குகிறது: Set-இல் duplicates, தோல்வியடைந்த map lookups, போன்றவை.
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) உங்களுக்காக சரியான, நிலையான equals/hashCode-ஐ உருவாக்குகின்றன.
equals/hashCode contract என்பது Java-வின் மிக முக்கியமான — மற்றும் மிகவும் பொதுவாக மீறப்படும் — விதிகளில் ஒன்றாகும்.
hashCode() இல்லாமல் equals()-ஐ override செய்வது hash-அடிப்படையிலான collections-ஐ debug செய்வதற்கு கடினமான வழிகளில் உடைக்கிறது: நீங்கள் சமமாக கருதும் objects வெவ்வேறு buckets-க்கு hash செய்வதால் HashMap/HashSet-இல் "தொலைந்து போகின்றன" (தோல்வியடைந்த lookups, phantom duplicates).
இந்த collections எங்கும் இருப்பதால், key அல்லது set element ஆகப் பயன்படுத்தப்படும் ஒவ்வொரு value-type class-ம் இரண்டையும் நிலையாக override செய்ய வேண்டும்.
ஏன் (bucket-then-equals lookup பொறிமுறை) என்பதைப் புரிந்துகொள்வது — மற்றும் அதைச் சரியாகப் பெற records அல்லது generated code-ஐ பயன்படுத்துவது — சரியான behavior-க்கு அவசியம் மற்றும் Java collections எவ்வாறு செயல்படுகின்றன என்பதன் உண்மையான புரிதலை வெளிப்படுத்தும் ஒரு கிளாசிக் interview தலைப்பு ஆகும்.