რატომ უნდა override გააკეთო equals()-სა და hashCode()-ზე ერთად?

Question

Accepted Answer

როდესაც override აკეთებ `equals()`-ს ლოგიკური ტოლობის განსაზღვრისთვის, **უნდა** აგრეთვე override გააკეთო `hashCode()`-ზე — რადგან hash-ბაზირებული კოლექციები (`HashMap`, `HashSet`) დამოკიდებელია კონტრაქტზე, რომელიც გამოხატავს, რომ **ტოლი ობიექტებს აქვთ ტოლი hash კოდები**. ამის დარღვევა იწვევს დაფარულ და რთულად აღმოჩნობილ ხარვეზებს. ## ნაგულისხმევი ქცევა ```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 ``` override-ის გარეშე, ორი ობიექტი იდენტური შინაარსით არ ითვლებიან "ტოლად" — ეს ჩვეულებრივ არ არის რაც გინდა value ობიექტებისთვის. ## 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 } ``` ## კრიტიკული წესი: აგრეთვე override გააკეთო hashCode()-ზე ```java @Override public int hashCode() { return Objects.hash(name, age); // MUST be consistent with equals() } ``` **კონტრაქტი:** თუ `a.equals(b)` true-ს უბრუნებს, მაშინ `a.hashCode() == b.hashCode()` **აუცილებელია** true იყოს. ## რა ისე ხდება თუ override გააკეთებ equals()-ზე მაგრამ არა 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 ჯერ `hashCode()`-ს იყენებს სწორი **ucket**-ის მოსაძებნად, შემდეგ `equals()`-ს მის შიგნით. ნაგულისხმევი (identity-based) `hashCode()`-ით, `p1` და `p2` ხვდებიან *სხვადსხვა* ucket-ებში, ამიტომ `contains` მათ არასოდეს აკმარებს — set-ი ფიქრობს, რომ ისინი განსხვავებული არიან. ეს იწვევს აბნორმალურ ხარვეზებს: დუბლირებული ელემენტები Set-ში, ვერ განხორციელებული მოძებნა რუკაში და სხვ. ## კონტრაქტის წესები ```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 ``` ## თანამედროვე მხოლოდ ```java record Person(String name, int age) {} // records auto-generate equals/hashCode/toString! ``` Java **records** (და IDE generation / Lombok) აწარმოებს სწორ და თანმიმდევრულ `equals`/`hashCode`-ს თქვენთვის. ## რატომ არის ეს მნიშვნელოვანი equals/hashCode კონტრაქტი არის Java-ს ერთ-ერთი ყველაზე მნიშვნელოვანი — და ყველაზე ხშირად დარღვეული — წესი. equals()-ის override hashCode()-ის გარეშე ხმელი აკეთებს hash-ბაზირებულ კოლექციებს გაკრეკილი გზით: ობიექტები, რომელთა თანაბრად ფიქრობთ, "კარგავთ" `HashMap`/`HashSet`-ში (მოძებნა ვერ განხორციელდა, გამოჩეკილი დუბლიკატები) რადგან ისინი hash ხდებიან სხვადსხვა ucket-ებში. ვინაიდან ეს კოლექციები ყველგან გამოიყენება, ყველა value-type კლასი, რომელიც გამოიყენება როგორც გასაღები ან set ელემენტი, უნდა override გააკეთოს **ორივე** თანმიმდევრულად. *რატომ* (ucket-then-equals ძებნის მექანიზმი) გაგება — და records ან გენერირებული კოდი გამოყენებით სწორად გაკეთება — აუცილებელია სწორი ქცევისთვის და კლასიკური ინტერვიუს თემა, რომელიც აჩვენებს ნამდვილი გაგება იმის შესახებ, თუ როგორ მუშაობს Java კოლექციები.