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

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

مجموعے

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

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

• hasNext() - اگر پوائنٹر کے بعد کوئی عنصر موجود ہو تو صحیح لوٹتا ہے (یہ طریقہ آپ کو یہ معلوم کرنے کی اجازت دیتا ہے کہ آیا مجموعہ کا اختتام ہوچکا ہے)؛
• next() - پوائنٹر کے بعد اگلا عنصر لوٹاتا ہے۔ اگر کوئی نہیں ہے تو، NoSuchElementException پھینک دیا جاتا ہے ۔ یعنی، اس طریقہ کو استعمال کرنے سے پہلے، یہ یقینی بنانا بہتر ہے کہ عنصر موجود ہے - استعمال کرتے ہوئے hasNext() ;
• remove() - اگلا() طریقہ استعمال کرتے ہوئے مجموعہ سے موصول ہونے والے آخری عنصر کو ہٹاتا ہے ۔ اگر next() کو ہٹانے سے پہلے کبھی نہیں بلایا گیا تو، ایک استثناء دیا جائے گا - IllegalStateException ؛
• 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>) - اگلے() یا پچھلے() طریقوں سے لوٹائے گئے آخری عنصر کو بدل دیتا ہے ۔

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

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

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

• سیٹ ایک انٹرفیس ہے جو اس طرح کے ڈیٹا ڈھانچے کو غیر ترتیب شدہ منفرد (غیر دہرائے جانے والے) عناصر پر مشتمل سیٹ کے طور پر بیان کرتا ہے۔ انٹرفیس میں معیاری نفاذ ہیں - TreeSet ، HashSet اور LinkedHashSet ۔
• فہرست ایک انٹرفیس ہے جو ڈیٹا ڈھانچے کی وضاحت کرتا ہے جو اشیاء کی ترتیب شدہ ترتیب کو محفوظ کرتا ہے۔ فہرست میں موجود مثالوں کو اس مجموعہ میں ان کے انڈیکس کے ذریعے داخل اور حذف کیا جا سکتا ہے (ایک صف کے مطابق، لیکن متحرک سائز کے ساتھ)۔ انٹرفیس میں معیاری نفاذ ہیں - ArrayList , Vector ( متروک سمجھا جاتا ہے اور حقیقت میں استعمال نہیں کیا جاتا ہے ) اور LinkedList ۔
• قطار ایک ایسا انٹرفیس ہے جو ڈیٹا کے ڈھانچے کی وضاحت کرتا ہے جو عناصر کو قطار کی شکل میں ذخیرہ کرتا ہے جو FIFO - First In First Out اصول کی پیروی کرتا ہے ۔ انٹرفیس میں درج ذیل معیاری نفاذات ہیں: LinkedList (ہاں، یہ قطار کو بھی لاگو کرتا ہے) اور PriotityQueue ۔

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

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

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

<размерТекущегоМассива> * 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(N) سے O(1) تک ہوتی ہے اس بات پر منحصر ہے کہ عنصر کہاں داخل کیا گیا ہے۔ 2. سیٹ(<Index>,<Element>) - ایک عنصر کو فہرست میں مخصوص پوزیشن پر لکھتا ہے۔ اگر اس پوزیشن پر پہلے سے ہی کوئی عنصر موجود ہے تو اسے اوور رائٹ کرتا ہے۔ اس آپریشن کی لوگارتھمک پیچیدگی O(1) ہے، کیونکہ اس میں کوئی تبدیلیاں نہیں ہیں: صرف صف میں انڈیکس کے ذریعے تلاش کرنا، جو کہ ہمیں یاد ہے، O(1) کی پیچیدگی ہے، اور عنصر لکھنا۔ 3. ہٹائیں(<index>) - کسی عنصر کو اندرونی صف میں اس کے انڈیکس کے ذریعے ہٹانا۔ کسی ایسے آئٹم کو حذف کرتے وقت جو فہرست کے آخر میں نہیں ہے، آپ کو تمام آئٹمز کو اس کے ایک سیل کے دائیں طرف بائیں طرف منتقل کرنا ہوگا تاکہ آئٹم کو حذف کرنے کے بعد بائیں خلا کو بند کیا جا سکے۔ لہذا، لوگارتھمک پیچیدگی ایک جیسی ہوگی add(<Index>,<Element>) اگر عنصر درمیان میں تھا - O(N/2) - کیونکہ آپ کو آدھے عناصر کو ایک بائیں طرف منتقل کرنے کی ضرورت ہے۔ اس کے مطابق، اگر یہ شروع میں تھا - O(N)۔ ٹھیک ہے، اگر آخر میں یہ O(1) ہے، تو کسی چیز کو منتقل کرنے کی ضرورت نہیں ہے۔ ان لوگوں کے لیے جو اس موضوع میں مزید گہرائی میں جانا چاہتے ہیں، میں اس لنک کو ArrayList کلاس کے تجزیہ کے ساتھ ایک مضمون پر چھوڑ دوں گا ۔

87. LinkedList کی اندرونی ساخت کیا ہے؟

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

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

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

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

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

Node<K,V>[] table

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

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

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