جاوا ڈویلپر کی پوزیشن کے لیے نوکری کے انٹرویو سے سوالات اور جوابات تلاش کرنا۔ حصہ 9

پروگرامر بننا آسان نہیں ہے۔ سیکھنے کے لیے ہمیشہ کچھ نیا ہوتا ہے۔ اور، کسی بھی دوسری کوشش کی طرح، سب سے مشکل کام شروع کرنا ہے، اپنے مقصد کی طرف پہلا قدم اٹھانا۔ لیکن چونکہ آپ پہلے ہی یہاں ہیں اور یہ مضمون پڑھ رہے ہیں، آپ نے پہلا مرحلہ مکمل کر لیا ہے۔ اس کا مطلب یہ ہے کہ اب آپ کو جان بوجھ کر اپنے مقصد کی طرف بڑھنے کی ضرورت ہے، بغیر سست ہوئے یا کسی طرف ہٹے بغیر۔ میں فرض کرتا ہوں کہ آپ کا مقصد جاوا ڈویلپر بننا ہے یا اگر آپ پہلے سے ہی ایک ڈویلپر ہیں تو اپنے علم کو بڑھانا ہے۔ اگر ایسا ہے تو، آئیے جاوا ڈویلپر انٹرویو کے سوالات کی ایک وسیع فہرست سے نمٹنا جاری رکھیں۔ آئیے جاری رکھیں!

مجموعے

84. ہمیں تکرار کرنے والوں کے بارے میں بتائیں اور ان کا استعمال کیسے کیا جاتا ہے۔

جاوا ڈویلپر کے کسی بھی انٹرویو میں مجموعے ایک پسندیدہ موضوع ہے۔ جب مجموعہ کے درجہ بندی کے بارے میں سوالات کے جوابات دیتے ہیں، امیدوار اکثر کہتے ہیں کہ یہ مجموعہ انٹرفیس سے شروع ہوتا ہے۔ لیکن ایسا نہیں ہے۔ ایک سطح کے اوپر ایک اور انٹرفیس ہے: Iterable ۔ یہ انٹرفیس iterator() طریقہ پر مشتمل ہے، جو آپ کو موجودہ مجموعہ کے لیے Iterator آبجیکٹ تک رسائی فراہم کرتا ہے۔ اور یہ Iterator اعتراض بالکل کیا ہے؟ Iterator آبجیکٹ ایک مجموعہ میں منتقل کرنے اور اس کے عناصر پر تکرار کرنے کی صلاحیت فراہم کرتا ہے، اور صارف کو مجموعہ کے نفاذ کی مخصوص تفصیلات جاننے کی ضرورت نہیں ہے۔ دوسرے الفاظ میں، یہ مجموعہ کے عناصر کی طرف اشارہ کرنے کی ایک قسم ہے، گویا یہ ان میں سے کسی ایک کے اندر جھانک رہا ہے۔ تکرار کرنے والے کے پاس طریقے ہیں جیسے:

• hasNext() — اگر تکرار میں کوئی اور عنصر ہو تو درست ہو جاتا ہے (یہ طریقہ آپ کو بتاتا ہے کہ آپ کب مجموعہ کے اختتام پر پہنچ چکے ہیں)؛

• next() — تکرار میں اگلی آئٹم واپس کرتا ہے۔ اگر کوئی نہیں ہے، تو NoSuchElementException پھینک دیا جاتا ہے۔ اس کا مطلب یہ ہے کہ اس طریقہ کو استعمال کرنے سے پہلے، hasNext() طریقہ استعمال کرنا بہتر ہے تاکہ یہ یقینی بنایا جا سکے کہ اگلا عنصر موجود ہے۔

• ہٹائیں () - اگلے() طریقہ کا استعمال کرتے ہوئے موصول ہونے والے آخری عنصر کو مجموعہ سے ہٹاتا ہے ۔ اگر next() کو کبھی نہیں بلایا گیا ہے، تو ریمو() کو کال کرنے سے ایک غیر قانونی اسٹیٹ ایکسیپشن پھینک دیا جائے گا۔

• forEachRemaining(<Consumer>) — مجموعے کے ہر عنصر پر منظور شدہ کارروائی کو انجام دیتا ہے (یہ طریقہ جاوا 8 میں ظاہر ہوا)۔

یہاں ایک فہرست کے ذریعے تکرار کرنے اور اس کے تمام عناصر کو مختلف تکرار کرنے والے طریقوں کا استعمال کرتے ہوئے ہٹانے کی ایک چھوٹی سی مثال ہے جن پر ہم نے دیکھا:

List<String> list = new ArrayList<>();
list.add("Hello ");
list.add("World, ");
list.add("It's ");
list.add("Amigo!");
Iterator iterator = list.iterator();

while(iterator.hasNext()) {
   iterator.next();
   iterator.remove();
}
System.out.println(list.size());

کنسول درج ذیل کو ظاہر کرے گا: اس کا مطلب ہے کہ عناصر کو کامیابی سے ہٹا دیا گیا تھا۔ ایک بار جب آپ کو تکرار کرنے والا مل جاتا ہے، تو آپ اسکرین پر موجود تمام عناصر کو ظاہر کرنے کے لیے ایک طریقہ استعمال کر سکتے ہیں:

iterator.forEachRemaining(x -> System.out.print(x));

لیکن ایک بار جب ہم یہ کر لیتے ہیں، تو تکرار کرنے والا مزید استعمال کے لیے نا مناسب ہو جاتا ہے: اس نے پوری فہرست کو عبور کر لیا ہے، اور ایک عام تکرار کرنے والے کے پاس پیچھے کی طرف تکرار کرنے کا کوئی طریقہ نہیں ہے۔ اور اس سے LinkedList ، خاص طور پر، اس کے listIterator() طریقہ کی بحث میں ایک اچھا حصہ بنتا ہے ، جو ایک بہتر قسم کی iterator واپس کرتا ہے: ListIterator ۔ باقاعدہ (معیاری) تکرار کرنے والے کے طریقوں کے علاوہ، اس قسم میں درج ذیل ہیں:

• add(<Element>) — فہرست میں ایک نیا عنصر شامل کرتا ہے۔

• hasPrevious() — صحیح لوٹاتا ہے اگر اگلے عنصر سے پہلے کوئی عنصر موجود ہو (اگر کوئی پچھلا عنصر ہے)؛

• nextIndex() - اگلے عنصر کا انڈیکس لوٹاتا ہے۔

• previous() — پچھلے عنصر کو لوٹاتا ہے (اگلے عنصر سے پہلے والا)؛

• previousIndex پچھلے عنصر کا انڈیکس لوٹاتا ہے۔

• set(<Element>) — next() یا previous() کے ذریعے واپس کیے گئے آخری عنصر کی جگہ لے لیتا ہے ۔

جیسا کہ آپ دیکھ سکتے ہیں، اس تکرار کنندہ میں بہت زیادہ دلچسپ فعالیت ہے: یہ آپ کو دونوں سمتوں میں چلنے دیتا ہے اور عناصر کے ساتھ کام کرتے وقت کافی آزادی فراہم کرتا ہے۔ آپ کو یہ بھی معلوم ہونا چاہیے کہ جب لوگ تکرار کرنے والوں کے بارے میں بات کرتے ہیں، تو ان کا مطلب کبھی کبھی خود ڈیزائن پیٹرن ہوتا ہے۔

85. جاوا کلیکشن فریم ورک میں کون سا مجموعہ درجہ بندی موجود ہے؟

جاوا میں مجموعہ کے دو درجہ بندی ہیں۔ پہلا درجہ بندی مجموعہ درجہ بندی ہے، جس کی ساخت درج ذیل ہے: اسے درج ذیل ذیلی مجموعوں میں تقسیم کیا گیا ہے:

• سیٹ ایک انٹرفیس ہے جو ایک سیٹ کی وضاحت کرتا ہے، ایک ڈیٹا ڈھانچہ جس میں غیر ترتیب شدہ منفرد (غیر دہرائے جانے والے) عناصر ہوتے ہیں۔ اس انٹرفیس میں کچھ معیاری نفاذات ہیں: TreeSet ، HashSet ، اور LinkedHashSet ۔

• فہرست ایک انٹرفیس ہے جو ڈیٹا ڈھانچے کو بیان کرتا ہے جو اشیاء کی ترتیب شدہ ترتیب کو محفوظ کرتا ہے۔ فہرست میں موجود اشیاء کو فہرست میں ان کے انڈیکس کے ذریعہ ڈالا اور ہٹایا جا سکتا ہے (جیسے ایک صف، لیکن متحرک سائز کے ساتھ)۔ اس انٹرفیس میں کچھ معیاری نفاذ بھی ہیں: ArrayList , Vector ( فرسودہ اور اصل میں استعمال نہیں کیا گیا )، اور LinkedList ۔

• قطار ایک انٹرفیس ہے جو ڈیٹا ڈھانچے کو بیان کرتا ہے جو فرسٹ ان فرسٹ آؤٹ (FIFO) قطار میں اشیاء کو اسٹور کرتا ہے۔ اس انٹرفیس میں درج ذیل معیاری نفاذات ہیں: LinkedList (یہ ٹھیک ہے، یہ Queue کو بھی لاگو کرتا ہے ) اور PriotityQueue ۔

دوسرا مجموعہ درجہ بندی نقشہ کا درجہ بندی ہے ، جس کا ڈھانچہ درج ذیل ہے: اس مجموعہ کے درجہ بندی میں ذیلی مجموعوں میں کوئی تقسیم نہیں ہے (چونکہ نقشہ کا درجہ بندی خود ایک ذیلی مجموعہ کی چیز ہے جو اپنے آپ سے الگ ہے)۔ معیاری نقشہ کے نفاذ ہیں Hashtable (فرسودہ)، LinkedHashMap ، اور TreeMap ۔ عملی طور پر، جب لوگ مجموعوں کے بارے میں پوچھتے ہیں ، تو ان کا مطلب عام طور پر دونوں درجہ بندی ہوتا ہے۔

86. ArrayList کی اندرونی ساخت کیا ہے؟

ایک ArrayList ایک صف کی طرح ہے، لیکن یہ متحرک طور پر پھیل سکتی ہے۔ اس کا کیا مطلب ہے؟ ہڈ کے نیچے، ArrayList ایک عام صف کا استعمال کرتی ہے، یعنی یہ اپنے عناصر کو اندرونی صف میں محفوظ کرتی ہے جس کا ڈیفالٹ سائز 10 سیلز ہوتا ہے۔ داخلی صف بھر جانے کے بعد، ایک نئی صف بنائی جاتی ہے۔ نئی صف کے سائز کا تعین اس فارمولے سے کیا جاتا ہے:

<size of the current array> * 3 / 2 + 1

لہذا، اگر ہماری صف کا سائز 10 ہے، تو نئے کا سائز یہ ہوگا: 10*3/2 + 1 = 16۔ پھر اصل (پرانی) صف کی تمام اقدار بلٹ ان کا استعمال کرتے ہوئے اس میں کاپی کی جاتی ہیں۔ System.arraycopy() طریقہ، اور اصل صف کو حذف کر دیا جاتا ہے۔ مختصراً، اسی طرح ArrayList ڈائنامک ریائزنگ کو لاگو کرتی ہے۔ آئیے سب سے زیادہ مقبول ArrayList طریقوں پر غور کریں: 1. add(<Element>) — ارے کے آخر میں ایک عنصر شامل کرتا ہے (آخری خالی سیل میں)، پہلے یہ چیک کرنے کے بعد کہ آیا سرنی میں کوئی سیل دستیاب ہے یا نہیں۔ اگر نہیں تو، ایک نئی صف بنائی جاتی ہے، اور عناصر کو اس میں کاپی کیا جاتا ہے۔ اس آپریشن کی وقتی پیچیدگی O(1) ہے۔ اسی طرح کا ایک add(<Index>, <Element>) طریقہ ہے ۔ یہ ایک عنصر کو فہرست کے آخر میں نہیں جوڑتا ہے (سرنی) بلکہ اس مخصوص سیل میں جو انڈیکس کے ذریعہ اشارہ کیا گیا ہے جو دلیل کے طور پر آیا ہے۔ اس صورت میں، وقت کی پیچیدگی اس بات پر منحصر ہوگی کہ آپ کہاں شامل کرتے ہیں:

• اگر اضافہ فہرست کے آغاز کے قریب ہے، تو وقت کی پیچیدگی O(N) کے قریب ہوگی، کیونکہ نئے کے دائیں جانب واقع تمام عناصر کو ایک سیل کو دائیں جانب منتقل کرنا ہوگا۔
• اگر عنصر کو درمیان میں ڈالا جاتا ہے، تو یہ O(N/2) ہوگا، کیونکہ ہمیں فہرست کے آدھے آئٹمز کو صرف ایک سیل کو دائیں طرف منتقل کرنے کی ضرورت ہے۔

یعنی، اس طریقہ کار کی وقت کی پیچیدگی O(1) سے O(N) تک ہوتی ہے، اس بات پر منحصر ہے کہ عنصر کہاں داخل کیا گیا ہے۔ 2. سیٹ(<Index>, <Element>) — ایک عنصر کو فہرست میں مخصوص پوزیشن پر لکھتا ہے۔ اگر کوئی عنصر اس پوزیشن پر پہلے سے موجود ہے، تو طریقہ اسے اوور رائٹ کر دیتا ہے۔ اس آپریشن کی وقتی پیچیدگی O(1) ہے، کیونکہ اس میں کوئی شفٹ آپریشن شامل نہیں ہے: ہم صف میں سیل کے ایڈریس کا حساب لگانے کے لیے صرف انڈیکس کا استعمال کرتے ہیں، جس کی پیچیدگی O(1) ہے، اور پھر نیا عنصر لکھتے ہیں۔ . 3. ہٹائیں(<index>) — کسی عنصر کو اندرونی صف میں اس کے اشاریہ سے ہٹاتا ہے۔ کسی ایسے آئٹم کو ہٹاتے وقت جو فہرست کے آخر میں نہیں ہے، حذف شدہ کے دائیں طرف تمام آئٹمز کو ایک سیل کو بائیں طرف منتقل کرنا ضروری ہے تاکہ حذف ہونے سے پیدا ہونے والے خلا کو ختم کیا جا سکے۔ اس کے مطابق، وقت کی پیچیدگی وہی ہوگی جو add(<Index>, <Element>) کے لیے ہوگی جب ایک عنصر درمیان میں شامل کیا جائے گا: O(N/2)۔ سب کے بعد، آپ کو آدھے عناصر کو ایک سیل کو بائیں طرف منتقل کرنے کی ضرورت ہے۔ اور اگر ہم شروعات کے بارے میں بات کر رہے ہیں، تو O(N)۔ یا اگر آخر میں، تو O(1)، کیونکہ آپ کو کچھ بھی منتقل کرنے کی ضرورت نہیں ہے۔

87. لنکڈ لسٹ کی اندرونی ساخت کیا ہے؟

ایک ArrayList اندرونی صف میں عناصر پر مشتمل ہوتی ہے، لیکن ایک LinkedList انہیں دوگنا منسلک فہرست میں اسٹور کرتی ہے۔ اس کا مطلب ہے کہ ہر عنصر میں پچھلے عنصر اور اگلے عنصر کا لنک ہوتا ہے ۔ پہلا عنصر پچھلے عنصر سے منسلک نہیں ہوتا ہے (بالآخر، یہ پہلا ہے)۔ اسے فہرست کا سربراہ بھی سمجھا جاتا ہے، اور LinkedList آبجیکٹ کا اس کا براہ راست حوالہ ہے۔ اسی طرح، آخری عنصر میں اگلا عنصر نہیں ہے، کیونکہ یہ فہرست کی دم ہے۔ لنکڈ لسٹ آبجیکٹ اس کا براہ راست حوالہ بھی دیتا ہے۔ اس کا مطلب ہے کہ فہرست کے سر یا دم تک رسائی کی وقتی پیچیدگی O(1) ہے۔ ArrayList میں ، اگر فہرست بڑھتی ہے، تو اندرونی صف بڑھ جاتی ہے۔ یہاں سب کچھ آسان ہے: حوالہ شامل کرنا اتنا ہی آسان ہے جتنا کہ چند لنکس کو تبدیل کرنا۔ آئیے LinkedList کے سب سے زیادہ استعمال ہونے والے طریقوں کو دیکھتے ہیں: 1. add(<Element>) — فہرست کے آخر میں ایک عنصر شامل کرتا ہے، یعنی آخری عنصر (5) کے بعد، نئے عنصر کا ایک لنک اگلے کے طور پر شامل کیا جائے گا۔ . نئے عنصر میں پچھلا حوالہ اس عنصر (5) کی طرف اشارہ کرے گا جو اب فہرست میں اس سے پہلے ہے۔ اس آپریشن کی وقتی پیچیدگی O(1) ہے، کیونکہ ہمیں صرف آخری عنصر سے لنک کی ضرورت ہے، اور جیسا کہ آپ کو یاد ہوگا، LinkedList آبجیکٹ کا براہ راست ٹیل کا حوالہ ہے، اور اس تک رسائی میں کم سے کم مستقل وقت کی پیچیدگی ہوتی ہے۔ 2. add(<Index>, <Element>) — انڈیکس کے لحاظ سے ایک عنصر شامل کرتا ہے۔ ایک عنصر کو شامل کرتے وقت، ایک فہرست کے وسط میں، یہ طریقہ سب سے پہلے سر اور دم (دونوں سمتوں پر) کے عناصر پر اعادہ کرتا ہے جب تک کہ مطلوبہ جگہ نہ مل جائے۔ اگر ہم تیسرے اور چوتھے عنصر کے درمیان ایک عنصر (اوپر کی تصویر میں) شامل کرتے ہیں، تو تیسرے عنصر کا اگلا لنک نئے عنصر کی طرف اشارہ کرے گا۔ اور نئے شامل کردہ عنصر کا پچھلا حصہ تیسرے کی طرف اشارہ کرے گا۔ بدلے میں، پرانے چوتھے عنصر کا پچھلا لنک اب نئے عنصر کی طرف اشارہ کرے گا، اور نئے عنصر کا اگلا لنک نئے چوتھے عنصر کی طرف اشارہ کرے گا: اس طریقہ کار کی وقت کی پیچیدگی نئے عنصر کے اشاریہ پر منحصر ہے:

• اگر یہ سر یا دم کے قریب ہے تو، آپریشن O(1) تک پہنچ جائے گا، کیونکہ عناصر پر اعادہ کرنا درحقیقت ضروری نہیں ہوگا۔
• اگر یہ وسط کے قریب ہے، تو ہمارے پاس O(N/2) ہوگا، کیونکہ طریقہ ایک ہی وقت میں سر اور دم سے تلاش کرے گا جب تک کہ مطلوبہ عنصر نہ مل جائے۔

3. سیٹ(<Index>, <Element>) — ایک عنصر کو فہرست میں مخصوص پوزیشن پر لکھتا ہے۔ اس آپریشن کی وقتی پیچیدگی O(1) سے O(N/2) تک ہوگی، دوبارہ اس بات پر منحصر ہے کہ نیا عنصر سر، دم، یا وسط سے کتنا قریب ہے۔ 4. ہٹائیں(<index>) — ایک عنصر کو فہرست سے اس طرح ہٹاتا ہے کہ حذف شدہ ( پچھلے ) سے پہلے کا عنصر اب حذف شدہ ( اگلا ) کے بعد کے عنصر سے مراد لے۔ اور اس کے برعکس، یعنی حذف شدہ کے بعد کا عنصر اب حذف شدہ سے پہلے والے کا حوالہ دیتا ہے: یہ عمل index ( add(<Index>, <Element>) ) کے ذریعے شامل کرنے کے برعکس ہے ۔

88. ہیش میپ کی اندرونی ساخت کیا ہے؟

یہ جاوا ڈویلپر امیدواروں سے پوچھنے کے لیے انٹرویو کے سب سے مشہور سوالات میں سے ایک ہو سکتا ہے۔ HashMap کلیدی قدر کے جوڑوں کے ساتھ کام کرتا ہے ۔ وہ HashMap کے اندر کیسے محفوظ ہیں ؟ ایک ہیش میپ میں نوڈس کی اندرونی صف ہوتی ہے:

Node<K,V>[] table

پہلے سے طے شدہ طور پر، صف کا سائز 16 ہوتا ہے، اور جب بھی یہ عناصر سے بھر جاتا ہے تو یہ دگنا ہو جاتا ہے (یعنی جب LOAD_FACTOR تک پہنچ جاتا ہے؛ یہ اس حد کی وضاحت کرتا ہے کہ صف کتنی بھری ہو سکتی ہے — پہلے سے طے شدہ طور پر، یہ 0.75 ہے ) . ہر نوڈس کلید کی ایک ہیش، کلید، ایک قدر، اور اگلے عنصر کے حوالے سے ذخیرہ کرتا ہے: اس صورت میں، "اگلے عنصر کا حوالہ" کا مطلب ہے کہ ہم اکیلے سے منسلک فہرست کے ساتھ کام کر رہے ہیں، جہاں ہر عنصر میں اگلے کا لنک ہوتا ہے۔ دوسرے الفاظ میں، ایک HashMap اپنے ڈیٹا کو اکیلے منسلک فہرستوں کی ایک صف میں محفوظ کرتا ہے۔ لیکن مجھے فوراً یہ کہنے دیجئے کہ جب ٹیبل اری کے سیل میں اکیلے سے منسلک فہرست ہوتی ہے جو ایک سے زیادہ عناصر پر مشتمل ہوتی ہے تو یہ اچھی بات نہیں ہے۔ اس رجحان کو ٹکراؤ کہا جاتا ہے ۔ لیکن سب سے پہلے چیزیں. آئیے دیکھتے ہیں کہ پوٹ میتھڈ کا استعمال کرتے ہوئے ایک نیا جوڑا کیسے محفوظ کیا جاتا ہے۔ سب سے پہلے، طریقہ کلید حاصل کرتا ہے hashCode() ۔ اس کا مطلب یہ ہے کہ HashMap کے درست طریقے سے کام کرنے کے لیے ، آپ جو کلیدیں استعمال کرتے ہیں وہ کلاسز ہونی چاہئیں جو اس طریقہ کو اوور رائیڈ کرتی ہیں۔ اس ہیش کوڈ کو پھر اندرونی ہیش() طریقہ میں استعمال کیا جاتا ہے تاکہ ٹیبل ارے کے اندر کچھ سیل کے انڈیکس کا تعین کیا جا سکے۔ نتیجے میں آنے والا انڈیکس ہمیں ٹیبل سرنی کے مخصوص سیل تک رسائی حاصل کرنے کی اجازت دیتا ہے۔ ہمارے یہاں دو صورتیں ہیں:

1. سیل خالی ہے - اس صورت میں، نئی نوڈ ویلیو اس میں محفوظ ہے۔
2. سیل خالی نہیں ہے — اس صورت میں، چابیاں کی قدروں کا موازنہ کیا جاتا ہے۔ اگر وہ برابر ہیں، تو نئی نوڈ ویلیو پرانی کو اوور رائٹ کر دیتی ہے۔ اگر برابر نہیں ہے، تو اگلی تک رسائی حاصل کی جاتی ہے، اور اس کی کلید کا موازنہ کیا جاتا ہے... اور اسی طرح، جب تک کہ نئی قدر یا تو کچھ پرانی قدر کو اوور رائٹ نہیں کر دیتی یا ہم اکیلے منسلک فہرست کے آخر تک پہنچ جاتے ہیں اور پھر نئی قدر کو وہاں ذخیرہ کرتے ہیں آخری عنصر.

کلید کے ذریعے کسی عنصر کی تلاش کرتے وقت ( get(<key>) طریقہ استعمال کرتے ہوئے، کلید کے hashCode() کا حساب لگایا جاتا ہے، اور پھر اس کے اندر موجود انڈیکس کو hash() کا استعمال کرتے ہوئے شمار کیا جاتا ہے ۔ نتیجے میں آنے والا نمبر ٹیبل اری میں ایک سیل کا انڈیکس ہے ، جسے ہم پھر نوڈس پر تکرار کرکے اور مطلوبہ نوڈ کی کلید کا موجودہ نوڈ کی کلید سے موازنہ کرکے تلاش کرتے ہیں۔ مثالی طور پر، نقشہ کی کارروائیوں میں O(1) کی الگورتھمک پیچیدگی ہوتی ہے، کیونکہ ہم ایک صف تک رسائی حاصل کر رہے ہیں، اور جیسا کہ آپ کو یاد ہوگا، O(1) ہے، قطع نظر اس کے عناصر کی تعداد سے قطع نظر۔ لیکن ہم مثالی کیس سے نمٹ نہیں رہے ہیں۔ جب سیل خالی نہیں ہوتا ہے (2) اور پہلے ہی کچھ نوڈس کو اسٹور کرتا ہے، تو الگورتھمک پیچیدگی O(N) (لکیری) بن جاتی ہے، کیونکہ اب ہمیں صحیح جگہ تلاش کرنے سے پہلے عناصر پر اعادہ کرنا ضروری ہے۔ میں مدد نہیں کرسکتا لیکن یہ بتا سکتا ہوں کہ جاوا 8 سے شروع کرتے ہوئے، اگر اکیلے سے منسلک فہرست کی شکل میں نوڈ میں 8 سے زیادہ عناصر (تصادم) ہوں تو یہ بائنری ٹری میں تبدیل ہوجاتا ہے۔ اس معاملے میں، الگورتھمک پیچیدگی اب O(N) نہیں ہے، بلکہ O(log(N)) — اور یہ ایک بالکل دوسرا معاملہ ہے، ہے نا؟ HashMap ایک بڑا موضوع ہے، اور لوگ نوکری کے انٹرویوز میں اس کے بارے میں سوالات پوچھنا پسند کرتے ہیں۔ لہذا، میرا مشورہ ہے کہ آپ اسے اپنے ہاتھ کے پچھلے حصے کی طرح جانتے ہوں۔ ذاتی طور پر، میں نے کبھی بھی ایسا انٹرویو نہیں لیا جس میں HashMap پر سوالات شامل نہ ہوں ۔ آج کیلئے بس اتنا ہی. جاری ہے...