⚖️ چرا باید equals و hashCode با هم Override شوند؟

برنامه‌نویسی شیءگرا در جاوا به شدت بر پایه‌ی مقایسه‌ی اشیاء است.
دو متد مهم که در این زمینه نقش حیاتی دارند، equals و hashCode هستند.



📌 متد equals

برای مقایسه‌ی محتوای دو شیء استفاده می‌شود.

به صورت پیش‌فرض از کلاس Object به ارث می‌رسد و فقط مقایسه‌ی آدرس حافظه انجام می‌دهد.

معمولاً باید آن را Override کنیم تا بتوانیم دو شیء با محتوای یکسان را برابر در نظر بگیریم.




📌 متد hashCode

این متد یک عدد صحیح (int) برمی‌گرداند که نشان‌دهنده‌ی یک Hash برای شیء است.

در ساختارهایی مثل HashMap, HashSet و Hashtable برای سریع پیدا کردن اشیاء استفاده می‌شود.

قرارداد جاوا می‌گوید:

اگر a.equals(b) درست باشد، باید a.hashCode() == b.hashCode() هم درست باشد.





🔎 مشکل وقتی فقط equals را Override کنیم

import java.util.HashSet;

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return name.equals(person.name);
    }
}

public class Test {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        set.add(new Person("Ali"));

        System.out.println(set.contains(new Person("Ali"))); // false
    }
}

📌 توضیح:

ما equals را Override کردیم اما hashCode را نه.

در واقع HashSet ابتدا hashCode را چک می‌کند تا موقعیت را پیدا کند. چون hashCode پیش‌فرض برای دو شیء متفاوت است، حتی اگر equals درست باشد، شیء پیدا نمی‌شود.




🔎 مثال درست با Override هر دو متد

import java.util.HashSet;
import java.util.Objects;

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

public class Test {
    publiSystem.out.println(String[] args) {
        HashSet<Person> set = new HashSet<>();
        set.add(new Person("Ali"));

        System.out.println(set.contains(new Person("Ali"))); // true
    }
}

📌 حالا چون هم equals و هم hashCode درست Override شده‌اند، مجموعه به درستی کار می‌کند.




🎯 جمع‌بندی

equals:
محتوای اشیاء را مقایسه می‌کند.

hashCode:
برای جست‌وجوی سریع در Collectionهای مبتنی بر Hash استفاده می‌شود.

اگر equals را Override کردید، حتماً باید hashCode را هم Override کنید، وگرنه ساختارهایی مثل HashSet و HashMap رفتار غیرمنتظره خواهند داشت.

#کاربرـپیشرفته

🆔 @javapro_ir
🆔 @group_javapro

🌟 قرارداد کامل equals و hashCode در جاوا


متد equals و hashCode دو بخش جدایی‌ناپذیر از قرارداد برابری در جاوا هستند. زمانی‌که شما این متدها را بازنویسی می‌کنید، باید قوانین مشخصی را رعایت کنید تا رفتار کلاس‌هایتان قابل پیش‌بینی و درست باقی بماند. این قوانین به صورت رسمی در مستندات جاوا تعریف شده‌اند.


قوانین متد equals:

۱️⃣ بازتابی بودن (Reflexive): هر شیء باید با خودش برابر باشد.

obj.equals(obj) // همیشه باید true باشد

۲️⃣ متقارن بودن (Symmetric): اگر a.equals(b) درست باشد، باید b.equals(a) هم درست باشد.

a.equals(b) == b.equals(a)

۳️⃣ گذرا بودن (Transitive): اگر a.equals(b) و b.equals(c) درست باشند، آنگاه a.equals(c) نیز باید درست باشد.

if(a.equals(b) && b.equals(c)) {
    a.equals(c) == true;
}

۴️⃣ سازگاری (Consistent): نتایج مقایسه باید در صورت تغییر نکردن وضعیت اشیاء ثابت بماند.

a.equals(b) // همیشه همان نتیجه را برمی‌گرداند تا وقتی که وضعیت a و b تغییر نکند

۵️⃣ عدم برابری با null: هیچ شیء نباید برابر با null باشد.

a.equals(null) // همیشه false

قوانین متد hashCode:

۱️⃣ سازگاری با equals: اگر دو شیء برابر باشند (equals آنها true باشد)، مقدار hashCode آن‌ها باید یکی باشد.

۲️⃣ سازگاری زمانی: تا زمانی که وضعیت شیء تغییر نکرده باشد، مقدار hashCode آن باید ثابت بماند.

۳️⃣ نامساوی‌ها ممکن است یکسان باشند: اگر دو شیء برابر نباشند، مجاز است که hashCode یکسانی داشته باشند، ولی توصیه می‌شود که تا جای ممکن متفاوت باشند.


مثال عملی:

import java.util.Objects;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
               Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

در این مثال، اگر دو شیء از نوع Person دارای نام و سن یکسان باشند، هم equals و هم hashCode آن‌ها برابر خواهد بود. این امر باعث می‌شود در ساختارهایی مثل HashSet یا HashMap رفتار درستی داشته باشند.


نتیجه‌گیری:
رعایت قرارداد equals و hashCode برای جلوگیری از خطاهای غیرمنتظره در مجموعه‌هایی مثل HashSet، HashMap و دیگر ساختارهای داده وابسته به هش بسیار حیاتی است. بی‌توجهی به این قوانین می‌تواند منجر به خطاهایی شود که پیدا کردن آن‌ها بسیار دشوار است.

#کاربرـپیشرفته

🆔 @javapro_ir
🆔 @group_javapro

📌 مفهوم Pass by Value در جاوا

در جاوا همه‌ی پارامترها به‌صورت Pass by Value (یعنی ارسال مقدار) به متدها منتقل می‌شوند.
اما بسیاری از برنامه‌نویسان در ابتدا فکر می‌کنند جاوا Pass by Reference دارد، چون وقتی یک آبجکت به متد ارسال می‌شود، تغییر روی آن آبجکت در بیرون متد هم دیده می‌شود.

🔎 بیایید دقیق‌تر نگاه کنیم:

اگر نوع‌های ابتدایی (Primitive) مثل int, double, boolean را ارسال کنید، مقدار کپی می‌شود. پس تغییرات داخل متد روی متغیر اصلی اثری ندارد.

اگر آبجکت را ارسال کنید، در واقع کپی آدرس آبجکت (Reference Value) ارسال می‌شود. بنابراین متد می‌تواند به همان آبجکت اشاره کرده و داده‌هایش را تغییر دهد. اما خود رفرنس اصلی کپی شده و تغییرش بی‌اثر است.

📘 مثال ۱ – نوع Primitive:

public class PassByValueDemo {
    public static void main(String[] args) {
        int x = 10;
        changeValue(x);
        System.out.println("x after method: " + x); // خروجی: 10
    }

    static void changeValue(int num) {
        num = 20; // فقط کپی تغییر می‌کند
    }
}

👉 نتیجه: مقدار x تغییر نکرد چون فقط کپی به متد داده شده بود.

📘 مثال ۲ – آبجکت‌ها:

class Person {
    String name;
}

public class PassByValueDemo2 {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "Ali";
        changeName(p);
        System.out.println("Person name: " + p.name); // خروجی: Reza
    }

    static void changeName(Person person) {
        person.name = "Reza"; // داده‌ی داخل آبجکت تغییر می‌کند
    }
}

👉 اینجا رشته‌ی name تغییر کرد، چون رفرنس کپی شده به همان آبجکت اشاره داشت.



📘 مثال ۳ – تغییر رفرنس داخل متد:

static void reassignObject(Person person) {
    person = new Person();
    person.name = "Sara";
}

public static void main(String[] args) {
    Person p = new Person();
    p.name = "Ali";
    reassignObject(p);
    System.out.println(p.name); // خروجی: Ali
}

👉 در اینجا مقدار name تغییر نکرد چون رفرنس اصلی کپی شده بود و تغییر رفرنس داخل متد روی متغیر اصلی بی‌اثر است.



✅ نتیجه‌گیری:
جاوا همیشه Pass by Value است، حتی برای آبجکت‌ها. فقط نکته این است که وقتی آبجکت‌ها را پاس می‌دهید، در واقع کپی رفرنس پاس می‌شود، نه خود آبجکت. همین موضوع باعث سردرگمی خیلی‌ها می‌شود.

#کاربرـپیشرفته

🆔 @javapro_ir
🆔 @group_javapro

📌موضوع: Immutable Objects در جاوا و ارتباط آن با Pass by Value

در جاوا بعضی از کلاس‌ها Immutable هستند؛ یعنی بعد از ساخته شدن، حالت داخلی آن‌ها دیگر تغییر نمی‌کند.
معروف‌ترین نمونه‌ی Immutable در جاوا، کلاس String است.

🔎 ویژگی اصلی Immutable این است که اگر به نظر برسد در حال تغییر دادن شیء هستیم، در واقع یک شیء جدید ساخته می‌شود و رفرنس متغیر به آن اشاره می‌کند.


📘 مثال ۱ – رشته‌ها (String):

public class ImmutableDemo {
    public static void main(String[] args) {
        String s = "Ali";
        changeString(s);
        System.out.println("Original: " + s); // خروجی: Ali
    }

    static void changeString(String str) {
        str = str + " Reza"; // شیء جدید ساخته می‌شود
        System.out.println("Inside method: " + str); // خروجی: Ali Reza
    }
}

👉 چرا خروجی نهایی هنوز Ali است؟
چون شیء رشته تغییر نکرد، بلکه یک String جدید ساخته شد و فقط رفرنس محلی (str) در متد به آن اشاره کرد.


📘 مثال ۲ – مقایسه با Mutable Object (مثل StringBuilder):

public class MutableDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Ali");
        changeBuilder(sb);
        System.out.println("After method: " + sb); // خروجی: Ali Reza
    }

    static void changeBuilder(StringBuilder builder) {
        builder.append(" Reza"); // همان شیء تغییر می‌کند
    }
}

👉 این بار شیء تغییر کرد، چون StringBuilder یک کلاس Mutable است.


✅ نتیجه‌گیری:

* جاوا همیشه Pass by Value است، اما رفتار Immutable vs Mutable تعیین می‌کند که داده‌ها "به ظاهر" تغییر می‌کنند یا نه.
* در مورد Immutableها مثل String، هر تغییری منجر به ساخت یک شیء جدید می‌شود.
* در مورد Mutableها مثل StringBuilder یا ArrayList، تغییرات مستقیماً روی همان شیء اثر می‌گذارد.

#کاربرـپیشرفته

🆔 @javapro_ir
🆔 @group_javapro

📌 موضوع: String Pool در جاوا و تفاوت == با equals

در جاوا رشته‌ها (`String`) یک ویژگی خاص دارند به نام String Pool. این مکانیزم باعث می‌شود مدیریت حافظه بهینه‌تر شود.


🔎 String Pool چیست؟
وقتی شما یک رشته با لیترال (Literal) بسازید، جاوا آن را در یک حافظه‌ی خاص به نام String Pool نگه می‌دارد. اگر دوباره همان رشته را با همان مقدار بسازید، جاوا از همان شیء موجود در String Pool استفاده می‌کند.


📘 مثال ۱ – استفاده از String Pool:

public class StringPoolDemo {
    public static void main(String[] args) {
        String s1 = "Ali";
        String s2 = "Ali";

        System.out.println(s1 == s2);      // true
        System.out.println(s1.equals(s2)); // true
    }
}

👉 چرا == اینجا true شد؟
چون هر دو متغیر به یک شیء یکسان در String Pool اشاره می‌کنند.


📘 مثال ۲ – استفاده از new String():

public class StringPoolDemo2 {
    public static void main(String[] args) {
        String s1 = new String("Ali");
        String s2 = new String("Ali");

        System.out.println(s1 == s2);      // false
        System.out.println(s1.equals(s2)); // true
    }
}

👉 این بار == false شد، چون هر بار که از new String() استفاده می‌کنیم، یک شیء جدید در حافظه Heap ساخته می‌شود (نه در String Pool).
اما equals() مقدار محتوای رشته را مقایسه می‌کند، بنابراین true می‌دهد.


📘 مثال ۳ – متد intern():

public class StringPoolDemo3 {
    public static void main(String[] args) {
        String s1 = new String("Ali");
        String s2 = s1.intern(); // این رشته وارد String Pool می‌شود
        String s3 = "Ali";

        System.out.println(s2 == s3); // true
    }
}

👉 متد intern() باعث می‌شود رشته وارد String Pool شود و از آن به بعد مقایسه با == هم true خواهد شد.


✅ نتیجه‌گیری:

* همیشه از equals() برای مقایسه‌ی مقدار رشته‌ها استفاده کنید.
* == فقط بررسی می‌کند که دو متغیر به یک شیء یکسان در حافظه اشاره می‌کنند.
* بهینه‌سازی حافظه در جاوا برای رشته‌ها به کمک String Pool انجام می‌شود.

#کاربر_مبتدی

🆔 @javapro_ir
🆔 @group_javapro

راه حلی برای اجرا کردن برنامه های روزانه ات

اگر میخوای آموزش ببینی، کتاب بخونی، ورزش کنی و... ولی اهمال کاری میکنی این راه حل مناسب شماست.

بخش اول

🆔 @javapro_ir
🆔 @group_javapro

راه حلی برای اجرا کردن برنامه های روزانه ات

بخش دوم (پایانی)

🆔 @javapro_ir
🆔 @group_javapro