જ્યારે તમે લોજિકલ સમાનતા વ્યાખ્યાયિત કરવા માટે equals() ને ઓવરરાઇડ કરો છો, તો તમે આવશ્યક રીતે hashCode() પણ ઓવરરાઇડ કરવો જોઈએ — કારણ કે હેશ-આધારિત કલેક્શન્સ (, ) તેના કરાર પર આધારિત છે. આ તોડવાથી સૂક્ષ્મ, શોધવામાં મુશ્કેલ બગ્સ તરફ દોરે છે.
જ્યારે તમે લોજિકલ સમાનતા વ્યાખ્યાયિત કરવા માટે equals() ને ઓવરરાઇડ કરો છો, તો તમે આવશ્યક રીતે hashCode() પણ ઓવરરાઇડ કરવો જોઈએ — કારણ કે હેશ-આધારિત કલેક્શન્સ (, ) તેના કરાર પર આધારિત છે. આ તોડવાથી સૂક્ષ્મ, શોધવામાં મુશ્કેલ બગ્સ તરફ દોરે છે.
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
ઓવરરાઇડ કર્યા વિના, સમાન કન્ટેન્ટ ધરાવતી બે વસ્તુઓ "સમાન નથી" છે — સામાન્યતઃ મૂલ્ય વસ્તુઓ માટે તમે જે ઇચ્છો છો તે નથી.
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 કલેક્શન્સ કેવી રીતે કાર્ય કરે છે તે વાસ્તવિક સમજણ જાહેર કરે છે તેના સાથે સાચું વર્તણૂક અને ક્લાસિક ઇન્ટરવ્યુ વિષય માટે આવશ્યક છે.
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો