مساوی اور ہیش کوڈ کے طریقے: استعمال کی مشق

ہیلو! آج ہم جاوا میں دو اہم طریقوں کے بارے میں بات کریں گے - equals()اور hashCode(). یہ پہلی بار نہیں ہے جب ہم ان سے ملے ہیں: JavaRush کورس کے آغاز میں اس بارے میں ایک مختصر لیکچرequals() تھا - اگر آپ اسے بھول گئے ہیں یا اسے پہلے نہیں دیکھا ہے تو اسے پڑھیں۔ آج کے سبق میں ہم ان تصورات کے بارے میں تفصیل سے بات کریں گے - مجھ پر یقین کریں، بات کرنے کے لیے بہت کچھ ہے! اور اس سے پہلے کہ ہم کسی نئی چیز کی طرف بڑھیں، آئیے اپنی یادداشت کو تازہ کریں جو ہم پہلے ہی احاطہ کر چکے ہیں :) جیسا کہ آپ کو یاد ہے، "" آپریٹر کا استعمال کرتے ہوئے دو اشیاء کا معمول کا موازنہ ==برا خیال ہے، کیونکہ " ==" حوالہ جات کا موازنہ کرتا ہے۔ یہاں ایک حالیہ لیکچر سے کاروں کے ساتھ ہماری مثال ہے:

public class Car {

   String model;
   int maxSpeed;

   public static void main(String[] args) {

       Car car1 = new Car();
       car1.model = "Ferrari";
       car1.maxSpeed = 300;

       Car car2 = new Car();
       car2.model = "Ferrari";
       car2.maxSpeed = 300;

       System.out.println(car1 == car2);
   }
}

کنسول آؤٹ پٹ:

false

ایسا لگتا ہے کہ ہم نے کلاس کی دو ایک جیسی اشیاء بنائی ہیں Car: دونوں مشینوں کے تمام فیلڈز ایک جیسے ہیں، لیکن موازنہ کا نتیجہ اب بھی غلط ہے۔ ہم پہلے سے ہی وجہ جانتے ہیں: لنکس car1اور car2میموری میں مختلف پتوں کی طرف اشارہ کرتے ہیں، لہذا وہ برابر نہیں ہیں. ہم اب بھی دو حوالوں کا نہیں بلکہ دو اشیاء کا موازنہ کرنا چاہتے ہیں۔ اشیاء کا موازنہ کرنے کا بہترین حل ہے equals()۔

مساوی () طریقہ

آپ کو یاد ہوگا کہ ہم یہ طریقہ شروع سے نہیں بناتے ہیں، بلکہ اسے اوور رائڈ کرتے ہیں - آخر کار، طریقہ equals()کلاس میں بیان کیا جاتا ہے Object۔ تاہم، اس کی معمول کی شکل میں یہ بہت کم مفید ہے:

public boolean equals(Object obj) {
   return (this == obj);
}

equals()کلاس میں طریقہ کی وضاحت اس طرح کی گئی ہے Object۔ لنکس کا ایک ہی موازنہ۔ اسے ایسا کیوں بنایا گیا؟ ٹھیک ہے، زبان کے تخلیق کاروں کو کیسے پتہ چلے گا کہ آپ کے پروگرام میں کون سی اشیاء برابر سمجھی جاتی ہیں اور کون سی نہیں؟ :) یہ طریقہ کار کا بنیادی خیال ہے equals()- کلاس کا خالق خود ان خصوصیات کا تعین کرتا ہے جن کے ذریعے اس طبقے کی اشیاء کی مساوات کی جانچ کی جاتی ہے۔ equals()ایسا کرنے سے، آپ اپنی کلاس میں طریقہ کو اوور رائیڈ کر دیتے ہیں ۔ اگر آپ "خود ہی خصوصیات کی وضاحت کرتے ہیں" کے معنی نہیں سمجھتے ہیں، تو آئیے ایک مثال دیکھیں۔ یہاں افراد کی ایک سادہ کلاس ہے - Man.

public class Man {

   private String noseSize;
   private String eyesColor;
   private String haircut;
   private boolean scars;
   private int dnaCode;

public Man(String noseSize, String eyesColor, String haircut, boolean scars, int dnaCode) {
   this.noseSize = noseSize;
   this.eyesColor = eyesColor;
   this.haircut = haircut;
   this.scars = scars;
   this.dnaCode = dnaCode;
}

   //getters, setters, etc.
}

ہم کہتے ہیں کہ ہم ایک پروگرام لکھ رہے ہیں جس میں یہ تعین کرنے کی ضرورت ہے کہ آیا دو افراد جڑواں بچوں سے متعلق ہیں، یا صرف ڈوپلگینگرز۔ ہمارے پاس پانچ خصوصیات ہیں: ناک کا سائز، آنکھوں کا رنگ، بالوں کا انداز، نشانات کی موجودگی اور ڈی این اے بائیولوجیکل ٹیسٹ کے نتائج (سادگی کے لیے - کوڈ نمبر کی شکل میں)۔ آپ کے خیال میں ان میں سے کون سی خصوصیات ہمارے پروگرام کو جڑواں رشتہ داروں کی شناخت کرنے کی اجازت دے گی؟ بلاشبہ، صرف حیاتیاتی ٹیسٹ ہی ضمانت فراہم کر سکتا ہے۔ دو لوگوں کی آنکھوں کا رنگ، بالوں کا انداز، ناک، یہاں تک کہ نشانات بھی ایک جیسے ہو سکتے ہیں - دنیا میں بہت سے لوگ ہیں، اور اتفاقات سے بچنا ناممکن ہے۔ ہمیں ایک قابل اعتماد طریقہ کار کی ضرورت ہے: صرف ڈی این اے ٹیسٹ کا نتیجہ ہی ہمیں درست نتیجہ اخذ کرنے کی اجازت دیتا ہے۔ ہمارے طریقہ کار کے لیے اس کا کیا مطلب ہے equals()؟ Manہمیں اپنے پروگرام کی ضروریات کو مدنظر رکھتے ہوئے کلاس میں اس کی دوبارہ وضاحت کرنے کی ضرورت ہے ۔ طریقہ کار کو دو اشیاء کے فیلڈ کا موازنہ کرنا چاہیے int dnaCode، اور اگر وہ برابر ہیں، تو اشیاء برابر ہیں۔

@Override
public boolean equals(Object o) {
   Man man = (Man) o;
   return dnaCode == man.dnaCode;
}

کیا یہ واقعی اتنا آسان ہے؟ واقعی نہیں۔ ہم نے کچھ یاد کیا۔ اس صورت میں، ہماری اشیاء کے لیے ہم نے صرف ایک "اہم" فیلڈ کی وضاحت کی ہے جس کے ذریعے ان کی مساوات قائم ہوتی ہے dnaCode۔ اب تصور کریں کہ ہمارے پاس 1 نہیں بلکہ 50 ایسی "اہم" فیلڈز ہوں گی۔ اور اگر دو آبجیکٹ کے تمام 50 فیلڈز برابر ہیں، تو اشیاء برابر ہیں۔ ایسا بھی ہو سکتا ہے۔ بنیادی مسئلہ یہ ہے کہ 50 شعبوں کی مساوات کا حساب لگانا ایک وقت طلب اور وسائل خرچ کرنے والا عمل ہے۔ اب تصور کریں کہ کلاس کے علاوہ، Manہمارے پاس ایک کلاس ہے Womanجس میں بالکل وہی فیلڈز ہیں Man۔ اور اگر کوئی دوسرا پروگرامر آپ کی کلاسوں کا استعمال کرتا ہے، تو وہ اپنے پروگرام میں آسانی سے کچھ لکھ سکتا ہے:

public static void main(String[] args) {

   Man man = new Man(........); //a bunch of parameters in the constructor

   Woman woman = new Woman(.........);//same bunch of parameters.

   System.out.println(man.equals(woman));
}

اس صورت میں، فیلڈ ویلیوز کو چیک کرنے کا کوئی فائدہ نہیں ہے: ہم دیکھتے ہیں کہ ہم دو مختلف طبقات کی اشیاء کو دیکھ رہے ہیں، اور وہ اصولی طور پر برابر نہیں ہو سکتے! اس کا مطلب یہ ہے کہ ہمیں طریقہ کار میں جانچ پڑتال کرنے کی ضرورت ہے equals()- دو ایک جیسی کلاسوں کی اشیاء کا موازنہ۔ یہ اچھا ہے کہ ہم نے اس کے بارے میں سوچا!

@Override
public boolean equals(Object o) {
   if (getClass() != o.getClass()) return false;
   Man man = (Man) o;
   return dnaCode == man.dnaCode;
}

لیکن شاید ہم کچھ اور بھول گئے؟ ہمم... کم از کم، ہمیں یہ چیک کرنا چاہیے کہ ہم شے کا خود سے موازنہ تو نہیں کر رہے! اگر حوالہ A اور B میموری میں ایک ہی ایڈریس کی طرف اشارہ کرتے ہیں، تو وہ ایک ہی آبجیکٹ ہیں، اور ہمیں 50 فیلڈز کا موازنہ کرنے میں وقت ضائع کرنے کی بھی ضرورت نہیں ہے۔

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (getClass() != o.getClass()) return false;
   Man man = (Man) o;
   return dnaCode == man.dnaCode;
}

اس کے علاوہ، اس کے لیے ایک چیک شامل کرنے سے کوئی نقصان نہیں ہوگا null: کوئی چیز اس کے برابر نہیں ہوسکتی null، اس صورت میں اضافی چیک کا کوئی فائدہ نہیں ہے۔ ان سب کو مدنظر رکھتے ہوئے، ہمارا equals()کلاس طریقہ Manکچھ یوں نظر آئے گا:

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;
   Man man = (Man) o;
   return dnaCode == man.dnaCode;
}

ہم اوپر بیان کردہ تمام ابتدائی جانچ پڑتال کرتے ہیں۔ اگر یہ پتہ چلتا ہے کہ:

• ہم ایک ہی کلاس کی دو اشیاء کا موازنہ کرتے ہیں۔
• یہ ایک ہی چیز نہیں ہے۔
• ہم اپنے اعتراض کا موازنہ نہیں کر رہے ہیں۔null

... پھر ہم اہم خصوصیات کا موازنہ کرنے کے لیے آگے بڑھتے ہیں۔ dnaCodeہمارے معاملے میں، دو اشیاء کے فیلڈز ۔ کسی طریقہ کو زیر کرتے وقت equals()، ان تقاضوں کی تعمیل یقینی بنائیں:

1. اضطراری صلاحیت۔

   equals()کوئی بھی شے اپنی ذات میں ہونی چاہیے ۔
   ہم نے پہلے ہی اس ضرورت کو مدنظر رکھا ہے۔ ہمارا طریقہ بتاتا ہے:

   if (this == o) return true;

2. ہم آہنگی

   اگر a.equals(b) == true، تو b.equals(a)اسے واپس آنا چاہیے true۔
   ہمارا طریقہ بھی اس ضرورت کو پورا کرتا ہے۔

3. منتقلی

   اگر دو اشیاء کسی تیسرے شے کے برابر ہیں، تو ان کا ایک دوسرے کے برابر ہونا چاہیے۔
   اگر a.equals(b) == trueاور a.equals(c) == true، تو چیک کو b.equals(c)بھی صحیح واپس آنا چاہیے۔

4. مستقل مزاجی

   کام کے نتائج equals()تبھی تبدیل ہونے چاہئیں جب اس میں شامل فیلڈز تبدیل ہوں۔ اگر دو اشیاء کا ڈیٹا تبدیل نہیں ہوا ہے، تو چیک کے نتائج equals()ہمیشہ ایک جیسے ہونے چاہئیں۔

5. کے ساتھ عدم مساوات null۔

   کسی بھی چیز کے لیے، چیک کو a.equals(null)غلط لوٹانا چاہیے
   یہ صرف کچھ "مفید سفارشات" کا مجموعہ نہیں ہے، بلکہ اوریکل دستاویزات میں تجویز کردہ طریقوں کا ایک سخت معاہدہ ہے۔

hashCode() طریقہ

اب طریقہ کی بات کرتے ہیں hashCode()۔ اس کی ضرورت کیوں ہے؟ بالکل اسی مقصد کے لیے - اشیاء کا موازنہ کرنا۔ لیکن ہمارے پاس پہلے ہی موجود ہے equals()! دوسرا طریقہ کیوں؟ جواب آسان ہے: پیداواری صلاحیت کو بہتر بنانے کے لیے۔ ایک ہیش فنکشن، جو جاوا میں , طریقہ سے ظاہر ہوتا ہے hashCode()، کسی بھی چیز کے لیے ایک مقررہ لمبائی عددی قدر لوٹاتا ہے۔ جاوا کے معاملے میں، طریقہ hashCode()32 بٹ نمبر کی قسم واپس کرتا ہے int۔ ایک دوسرے کے ساتھ دو نمبروں کا موازنہ طریقہ استعمال کرتے ہوئے دو اشیاء کا موازنہ کرنے سے کہیں زیادہ تیز ہے equals()، خاص طور پر اگر یہ بہت سے فیلڈز کا استعمال کرتا ہے۔ اگر ہمارا پروگرام اشیاء کا موازنہ کرے گا، تو ہیش کوڈ کے ذریعے ایسا کرنا بہت آسان ہے، اور صرف اس صورت میں جب وہ برابر ہوں hashCode()- by comparison کے لیے آگے بڑھیں equals()۔ یہ، ویسے، ہیش پر مبنی ڈیٹا سٹرکچر کیسے کام کرتا ہے—مثال کے طور پر، جسے آپ جانتے ہیں HashMap! طریقہ hashCode()، جیسا کہ equals()، خود ڈویلپر کے ذریعہ اوور رائڈ کیا جاتا ہے۔ اور بالکل اسی طرح جیسے for equals(), طریقہ hashCode()میں اوریکل دستاویزات میں بیان کردہ سرکاری تقاضے ہیں:

1. اگر دو اشیاء برابر ہیں (یعنی طریقہ equals()درست آتا ہے)، تو ان کے پاس ایک ہی ہیش کوڈ ہونا چاہیے۔

   ورنہ ہمارے طریقے بے معنی ہو جائیں گے۔ کی طرف سے جانچ پڑتال hashCode()، جیسا کہ ہم نے کہا، کارکردگی کو بہتر بنانے کے لیے پہلے آنا چاہیے۔ اگر ہیش کوڈز مختلف ہیں تو چیک غلط ہو جائے گا، حالانکہ اشیاء اصل میں برابر ہیں (جیسا کہ ہم نے طریقہ میں بیان کیا ہے equals())۔

2. اگر کسی طریقہ کو hashCode()ایک ہی چیز پر متعدد بار بلایا جاتا ہے، تو اسے ہر بار ایک ہی نمبر لوٹانا چاہیے۔

3. قاعدہ 1 الٹا کام نہیں کرتا ہے۔ دو مختلف اشیاء میں ایک ہی ہیش کوڈ ہو سکتا ہے۔

تیسرا اصول تھوڑا الجھا ہوا ہے۔ یہ کیسے ہو سکتا ہے؟ وضاحت کافی آسان ہے۔ طریقہ hashCode()واپس آتا ہے int۔ intایک 32 بٹ نمبر ہے۔ اس کی قدروں کی ایک محدود تعداد ہے - -2,147,483,648 سے +2,147,483,647 تک۔ دوسرے لفظوں میں، تعداد کی صرف 4 ارب سے زیادہ تغیرات ہیں int۔ اب تصور کریں کہ آپ زمین پر تمام زندہ لوگوں کے بارے میں ڈیٹا ذخیرہ کرنے کے لیے ایک پروگرام بنا رہے ہیں۔ ہر شخص کا اپنا کلاس آبجیکٹ ہوگا Man۔ ~ 7.5 بلین لوگ زمین پر رہتے ہیں۔ دوسرے الفاظ میں، اس بات سے کوئی فرق نہیں پڑتا ہے کہ ہم اشیاء کو اعداد میں تبدیل کرنے کے لیے کتنا ہی اچھا الگورتھم Manلکھتے ہیں، ہمارے پاس کافی تعداد نہیں ہوگی۔ ہمارے پاس صرف 4.5 بلین آپشنز ہیں، اور بہت سے لوگ۔ اس کا مطلب یہ ہے کہ چاہے ہم کتنی ہی کوشش کریں، ہیش کوڈز کچھ مختلف لوگوں کے لیے ایک جیسے ہوں گے۔ اس صورت حال کو (دو مختلف اشیاء کے ہیش کوڈز کے ملاپ) کو ٹکراؤ کہا جاتا ہے۔ کسی طریقہ کو اوور رائیڈ کرتے وقت پروگرامر کے اہداف میں سے ایک hashCode()تصادم کی ممکنہ تعداد کو ممکنہ حد تک کم کرنا ہے۔ ان تمام اصولوں کو مدنظر رکھتے ہوئے hashCode()کلاس کے لیے ہمارا طریقہ کیسا نظر آئے گا ؟ Manاس طرح:

@Override
public int hashCode() {
   return dnaCode;
}

حیران ہوئے؟ :) غیر متوقع طور پر، لیکن اگر آپ ضروریات کو دیکھیں گے، تو آپ دیکھیں گے کہ ہم ہر چیز کی تعمیل کرتے ہیں۔ وہ آبجیکٹ جن کے لیے ہماری equals()واپسی سچ ہے میں برابر ہوں گی hashCode()۔ اگر ہماری دونوں اشیاء Manقدر میں برابر ہیں equals(یعنی ان کی ایک ہی قدر ہے dnaCode) تو ہمارا طریقہ ایک ہی نمبر لوٹائے گا۔ آئیے ایک زیادہ پیچیدہ مثال کو دیکھیں۔ ہم کہتے ہیں کہ ہمارے پروگرام کو کلیکٹر کلائنٹس کے لیے لگژری کاروں کا انتخاب کرنا چاہیے۔ جمع کرنا ایک پیچیدہ چیز ہے، اور اس کی بہت سی خصوصیات ہیں۔ 1963 کی ایک کار کی قیمت 1964 کی اسی کار سے 100 گنا زیادہ ہوسکتی ہے۔ 1970 کی ایک سرخ کار کی قیمت اسی سال کی اسی ساخت کی نیلی کار سے 100 گنا زیادہ ہوسکتی ہے۔ پہلی صورت میں، کلاس کے ساتھ Man، ہم نے زیادہ تر فیلڈز (یعنی شخصی خصوصیات) کو غیر اہم قرار دیا اور موازنہ کے لیے صرف فیلڈ کا استعمال کیا dnaCode۔ یہاں ہم ایک بہت ہی منفرد علاقے کے ساتھ کام کر رہے ہیں، اور اس میں معمولی تفصیلات نہیں ہو سکتی! یہاں ہماری کلاس ہے LuxuryAuto:

public class LuxuryAuto {

   private String model;
   private int manufactureYear;
   private int dollarPrice;

   public LuxuryAuto(String model, int manufactureYear, int dollarPrice) {
       this.model = model;
       this.manufactureYear = manufactureYear;
       this.dollarPrice = dollarPrice;
   }

   //... getters, setters, etc.
}

یہاں، موازنہ کرتے وقت، ہمیں تمام شعبوں کو مدنظر رکھنا چاہیے۔ کسی بھی غلطی کی وجہ سے کلائنٹ کو لاکھوں ڈالر کا نقصان ہو سکتا ہے، اس لیے محفوظ رہنا بہتر ہے:

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;

   LuxuryAuto that = (LuxuryAuto) o;

   if (manufactureYear != that.manufactureYear) return false;
   if (dollarPrice != that.dollarPrice) return false;
   return model.equals(that.model);
}

ہمارے طریقہ کار میں، equals()ہم ان تمام چیکوں کے بارے میں نہیں بھولے جن کے بارے میں ہم نے پہلے بات کی تھی۔ لیکن اب ہم اپنی اشیاء کے تینوں شعبوں میں سے ہر ایک کا موازنہ کرتے ہیں۔ اس پروگرام میں، ہر شعبے میں، برابری مطلق ہونی چاہیے۔ hashCodeکے بارے میں

@Override
public int hashCode() {
   int result = model == null ? 0 : model.hashCode();
   result = result + manufactureYear;
   result = result + dollarPrice;
   return result;
}

modelہماری کلاس میں فیلڈ ایک تار ہے۔ یہ آسان ہے: Stringطریقہ hashCode()کلاس میں پہلے ہی اوور رائڈ ہے۔ ہم فیلڈ کے ہیش کوڈ کا حساب لگاتے ہیں model، اور اس میں ہم دیگر دو عددی فیلڈز کا مجموعہ شامل کرتے ہیں۔ جاوا میں ایک چھوٹی سی چال ہے جو تصادم کی تعداد کو کم کرنے کے لیے استعمال کی جاتی ہے: ہیش کوڈ کا حساب لگاتے وقت، درمیانی نتیجہ کو ایک طاق پرائم نمبر سے ضرب دیں۔ سب سے زیادہ استعمال ہونے والا نمبر 29 یا 31 ہے۔ ہم ابھی ریاضی کی تفصیلات میں نہیں جائیں گے، لیکن مستقبل کے حوالے کے لیے، یاد رکھیں کہ انٹرمیڈیٹ کے نتائج کو کافی بڑی طاق عدد سے ضرب کرنے سے ہیش کے نتائج کو "پھیلانے" میں مدد ملتی ہے۔ فنکشن اور اسی ہیش کوڈ کے ساتھ کم اشیاء کے ساتھ ختم ہوتا ہے۔ LuxuryAuto میں ہمارے طریقہ کار کے لیے hashCode()یہ اس طرح نظر آئے گا:

@Override
public int hashCode() {
   int result = model == null ? 0 : model.hashCode();
   result = 31 * result + manufactureYear;
   result = 31 * result + dollarPrice;
   return result;
}

اس میکانزم کی تمام پیچیدگیوں کے بارے میں آپ StackOverflow پر اس پوسٹ کے ساتھ ساتھ Joshua Bloch کی کتاب " Effective Java " میں مزید پڑھ سکتے ہیں۔ آخر میں ایک اور اہم نکتہ بھی قابل ذکر ہے۔ ہر بار جب اوور رائیڈ کرتے وقت equals()، hashCode()ہم نے آبجیکٹ کے کچھ فیلڈز کو منتخب کیا، جنہیں ان طریقوں میں مدنظر رکھا گیا تھا۔ equals()لیکن کیا ہم اور میں مختلف شعبوں کو مدنظر رکھ سکتے ہیں hashCode()؟ تکنیکی طور پر، ہم کر سکتے ہیں۔ لیکن یہ ایک برا خیال ہے، اور اس کی وجہ یہ ہے:

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;

   LuxuryAuto that = (LuxuryAuto) o;

   if (manufactureYear != that.manufactureYear) return false;
   return dollarPrice == that.dollarPrice;
}

@Override
public int hashCode() {
   int result = model == null ? 0 : model.hashCode();
   result = 31 * result + manufactureYear;
   result = 31 * result + dollarPrice;
   return result;
}

LuxuryAuto کلاس equals()کے لیے ہمارے طریقے یہ ہیں ۔ hashCode()طریقہ میں hashCode()کوئی تبدیلی نہیں ہوئی، اور equals()ہم نے طریقہ سے فیلڈ کو ہٹا دیا model۔ اب ماڈل دو اشیاء کا بذریعہ موازنہ کرنے کی خصوصیت نہیں ہے equals()۔ لیکن ہیش کوڈ کا حساب لگاتے وقت اسے اب بھی مدنظر رکھا جاتا ہے۔ اس کے نتیجے میں ہمیں کیا ملے گا؟ آئیے دو کاریں بنائیں اور اسے چیک کریں!

public class Main {

   public static void main(String[] args) {

       LuxuryAuto ferrariGTO = new LuxuryAuto("Ferrari 250 GTO", 1963, 70000000);
       LuxuryAuto ferrariSpider = new LuxuryAuto("Ferrari 335 S Spider Scaglietti", 1963, 70000000);

       System.out.println("Are these two objects equal to each other?");
       System.out.println(ferrariGTO.equals(ferrariSpider));

       System.out.println("What are their hash codes?");
       System.out.println(ferrariGTO.hashCode());
       System.out.println(ferrariSpider.hashCode());
   }
}

Эти два an object равны друг другу?
true
Какие у них хэш-codeы?
-1372326051
1668702472

غلطی! کے لیے مختلف شعبوں کا استعمال کرکے equals()اور hashCode()ہم نے ان کے لیے قائم کردہ معاہدے کی خلاف ورزی کی! دو مساوی equals()اشیاء کا ایک ہی ہیش کوڈ ہونا ضروری ہے۔ ہمیں ان کے مختلف معنی ملے۔ اس طرح کی غلطیاں سب سے زیادہ ناقابل یقین نتائج کا باعث بن سکتی ہیں، خاص طور پر جب ہیش استعمال کرنے والے مجموعوں کے ساتھ کام کرنا۔ لہذا، جب دوبارہ وضاحت کی جائے equals()اور hashCode()اسی فیلڈز کو استعمال کرنا درست ہو گا۔ لیکچر کافی لمبا نکلا، لیکن آج آپ نے بہت سی نئی چیزیں سیکھیں! :) یہ مسائل کو حل کرنے کے لئے واپس حاصل کرنے کا وقت ہے!