જ્યારે તમે લોજિકલ સમાનતા વ્યાખ્યાયિત કરવા માટે equals() ને ઓવરરાઇડ કરો છો, તો તમે આવશ્યક રીતે hashCode() પણ ઓવરરાઇડ કરવો જોઈએ — કારણ કે હેશ-આધારિત કલેક્શન્સ (HashMap, ) તેના કરાર પર આધારિત છે. આ તોડવાથી સૂક્ષ્મ, શોધવામાં મુશ્કેલ બગ્સ તરફ દોરે છે.
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
ઓવરરાઇડ કર્યા વિના, સમાન કન્ટેન્ટ ધરાવતી બે વસ્તુઓ "સમાન નથી" છે — સામાન્યતઃ મૂલ્ય વસ્તુઓ માટે તમે જે ઇચ્છો છો તે નથી.
equals() ને ઓવરરાઇડ કરવું@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
public int hashCode() {
return Objects.hash(name, age); // MUST be consistent with equals()
}
કરાર: જો a.equals(b) સાચું છે, તો a.hashCode() == b.hashCode() ને આવશ્યક રીતે સાચું હોવું જોઈએ.
equals() ને ઓવરરાઇડ કરો પણ 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 પહેલા સાચો બકેટ શોધવા માટે hashCode() વાપરે છે, પછી તેની અંદર equals() વાપરે છે. ડિફોલ્ટ (આઈડેન્ટિટી-આધારિત) hashCode() સાથે, p1 અને p2 અલગ બકેટમાં જાય છે, તેથી contains ક્યારેય તેમને સરખાવતું નથી — સેટ વિચારે છે કે તેઓ અલગ છે. આ ગભરાતા બગ્સ ઉત્પન્ન કરે છે: સેટમાં ડુપ્લિકેટ્સ, નિષ્ફળ નકશા લુકઅપ્સ, વગેરે.
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 રેકોર્ડ્સ (અને IDE જનરેશન / Lombok) તમારા માટે સાચું, સુસંગત equals/hashCode બનાવે છે.
equals/hashCode કરાર Java ના સૌથી મહત્વપૂર્ણ — અને સૌથી વધુ ઉલ્લંઘન કરેલા — નિયમો પૈકી એક છે.
equals() ને hashCode() વિના ઓવરરાઇડ કરવાથી હેશ-આધારિત કલેક્શન્સ તોડી જાય છે એવી રીતે જે ડીબગ કરવામાં મુશ્કેલ છે: તમે જે વસ્તુઓને સમાન માનો છો તે HashMap/HashSet માં "ખોવાઈ" જાય છે (નિષ્ફળ લુકઅપ્સ, ફેન્ટમ ડુપ્લિકેટ્સ) કારણ કે તેઓ અલગ બકેટમાં હેશ થાય છે.
ચાલુ આ કલેક્શન્સ સર્વવ્યાપી છે, કી અથવા સેટ એલિમેન્ટ તરીકે વાપરવામાં આવતો પ્રતિ મૂલ્ય-પ્રકાર ક્લાસ બંને સુસંગત રીતે ઓવરરાઇડ કરવો જોઈએ.
શા માટે સમજવું (બકેટ-પછી-સમાન લુકઅપ મિકેનિઝમ) — અને રેકોર્ડ્સ અથવા જનરેટ કરેલ કોડ વાપરીને તે સાચું પાડવું — Java કલેક્શન્સ કેવી રીતે કાર્ય કરે છે તે વાસ્તવિક સમજણ જાહેર કરે છે તેના સાથે સાચું વર્તણૂક અને ક્લાસિક ઇન્ટરવ્યુ વિષય માટે આવશ્યક છે.