جاوا ڊولپر لاءِ انٽرويوز کان سوالن ۽ جوابن جو تجزيو. حصو 9

آتش بازي! هڪ پروگرامر هجڻ آسان ناهي. توهان کي مسلسل سکڻ جي ضرورت آهي، هميشه ڪجهه نئين سکيو. پر، جيئن ڪنهن ٻئي ڪاروبار ۾، سڀ کان ڏکيو ڪم شروع ڪرڻ آهي، توهان جي مقصد ڏانهن پهريون قدم کڻڻ. ۽ جڏهن کان توهان هن سائيٽ تي ويٺا آهيو ۽ هي مضمون پڙهي رهيا آهيو، توهان پهريون قدم مڪمل ڪيو آهي. هن جو مطلب اهو آهي ته هاڻي توهان کي پنهنجي مقصد ڏانهن مقصد سان اڳتي وڌڻ جي ضرورت آهي، بغير سست ٿيڻ يا رستي ۾ بند ٿيڻ جي. جيڪڏهن مان سمجهان ٿو صحيح طرح، توهان جو مقصد آهي هڪ جاوا ڊولپر ٿيڻ يا توهان جي ڄاڻ کي وڌائڻ جيڪڏهن توهان هڪ آهيو. جيڪڏهن ائين آهي، ته پوءِ توهان صحيح جاءِ تي آهيو، ڇو ته اسان 250+ جاوا ڊولپر جي انٽرويو سوالن جي وسيع فهرست جو تجزيو ڪندا رهنداسين. اچو ته جاري رکون!

مجموعو

84. اسان کي ٻڌاءِ اِيٽرٽرز ۽ انهن جي استعمال بابت

جاوا ڊولپر جي ڪنهن به انٽرويو ۾ مجموعا هڪ پسنديده موضوع آهن، ۽ جڏهن گڏ ڪرڻ واري درجه بندي بابت ڳالهائيندي، اميدوار اڪثر چوندا آهن ته اهو گڏ ڪرڻ جي انٽرفيس سان شروع ٿئي ٿو . پر اهو سچ ناهي، ڇاڪاڻ ته هن انٽرفيس جي مٿان هڪ ٻيو آهي - Iterable . هي انٽرفيس نمائندگي ڪري ٿو iterator() طريقو ، جيڪو توهان کي اجازت ڏئي ٿو هڪ Iterator اعتراض کي ڪال ڪرڻ جي موجوده مجموعي لاءِ. ۽ اصل ۾ هي Iterator اعتراض ڇا آهي ؟ هڪ آئٽرٽر هڪ اعتراض آهي جيڪو هڪ مجموعو ذريعي منتقل ڪرڻ جي صلاحيت فراهم ڪري ٿو ۽ عناصر جي مٿان ٻيهر ورجائي ٿو بغير صارف کي ڪنهن خاص مجموعي جي عمل کي ڄاڻڻ جي ضرورت آهي. اهو آهي، اهو هڪ قسم جو اشارو آهي مجموعي جي عناصر ڏانهن، جيڪو، جيئن ته هو، ان ۾ هڪ خاص جڳهه تي نظر اچي ٿو. آئٽرٽر ھيٺ ڏنل طريقا آھن:

• hasNext() - واپسي صحيح آھي جيڪڏھن ڪو عنصر موجود آھي پوائنٽر کان پوءِ (ھي طريقو توھان کي معلوم ڪرڻ جي اجازت ڏئي ٿو ته ڇا مجموعو ختم ٿي ويو آھي)؛
• next() - پوائنٽر کان پوء ايندڙ عنصر کي واپس ڏئي ٿو. جيڪڏهن ڪو به ناهي، NoSuchElementException اڇلايو ويو آهي . اھو آھي، ھن طريقي کي استعمال ڪرڻ کان اڳ، اھو بھتر آھي ته پڪ ڪريو ته عنصر موجود آھي - hasNext() استعمال ڪندي ؛
• remove() - ايندڙ () طريقو استعمال ڪندي مجموعي مان حاصل ڪيل آخري عنصر کي هٽائي ٿو . جيڪڏهن اڳيون () ڪڏهن به نه سڏيو ويو آهي ان کان اڳ ريمو () سڏيو وڃي ٿو، هڪ استثنا اڇلايو ويندو - 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() طريقو ، جيڪو هڪ جديد قسم جو itereator - ListIterator موٽائي ٿو . ان کان علاوه باقاعده (معياري) ريٽٽر طريقن سان، هن وٽ اضافي آهن:

• add(<Element>) - لسٽ ۾ نئون عنصر داخل ڪري ٿو؛
• hasPrevious() - واپسي صحيح آھي جيڪڏھن ڪو عنصر موجود آھي پوائنٽر کان اڳ (ڇا اتي ھڪڙو اڳوڻو عنصر آھي)؛
• nextIndex() - انڊيڪس کي واپس ڪري ٿو ايندڙ عنصر جي لسٽ ۾ پوائنٽر کان پوء؛
• پوئين () - پوئين عنصر کي واپس ڏئي ٿو (پوائنٽ تائين)؛
• اڳوڻو انڊيڪس () - پوئين عنصر جي انڊيڪس موٽائي ٿو؛
• set(<Element>) - ايندڙ () يا پوئين() طريقن سان موٽايل آخري عنصر کي بدلائي ٿو .

جئين توهان ڏسي سگهو ٿا، هن آئٽرٽر جي ڪارڪردگي گهڻو وڌيڪ دلچسپ آهي: اهو توهان کي ٻنهي طرفن ۾ منتقل ڪرڻ جي اجازت ڏئي ٿو ۽ عناصر سان ڪم ڪرڻ دوران توهان جي هٿن کي آزاد ڪري ٿو. انهي سان گڏ، جڏهن ماڻهو ڳالهائيندڙن بابت ڳالهائيندو آهي، اهي ڪڏهن ڪڏهن پاڻ کي نموني جو مطلب آهي. مصيبت ۾ اچڻ کان بچڻ ۽ ان جي باري ۾ يقين سان ڳالهائڻ لاء، هي مضمون پڙهو Iterator نموني بابت .

85. جاوا ڪليڪشن فريم ورڪ ۾ ڪليڪشن hierarchy ڇا آهي؟

جاوا ۾ ٻه مجموعا hierarchies آهن. پهريون درجو آهي ڪليڪشن جو درجو پاڻ هيٺ ڏنل ڍانچي سان: اهو، بدلي ۾، هيٺين ذيلي مجموعن ۾ ورهايل آهي:

• سيٽ هڪ انٽرفيس آهي جيڪو بيان ڪري ٿو اهڙي ڊيٽا جي جوڙجڪ هڪ سيٽ جي طور تي غير ترتيب ڏنل منفرد (غير ورجائيندڙ) عناصر تي مشتمل آهي. انٽرفيس کي معياري لاڳو ڪيو ويو آهي - 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. اڳيون، پهرين (پراڻي) صفن مان سڀئي قيمتون ان ۾ نقل ڪيون وينديون آهن. native System.arraycopy () طريقو ، ۽ پھريون صف ختم ٿي وئي آھي. دراصل، ھي آھي ڪيئن متحرڪ وسعت واري ArrayList کي لاڳو ڪيو ويو آھي . اچو ته سڀ کان وڌيڪ استعمال ٿيندڙ ArrayList طريقن تي نظر رکون : 1. add(<Element>) - هڪ عنصر شامل ڪري ٿو صف جي آخر ۾ (آخري خالي سيل ڏانهن)، ۽ پھريائين چيڪ ڪريو ته ڇا ھن صف ۾ جاءِ آھي. جيڪڏهن اهو نه آهي، هڪ نئين صف ٺاهي وئي آهي جنهن ۾ عناصر نقل ڪيا ويا آهن. هن آپريشن جي منطقي پيچيدگي O (1) آهي. ھڪڙو ساڳيو طريقو آھي - add(<Index>,<Element>) . اهو هڪ عنصر شامل ڪري ٿو فهرست جي آخر ۾ نه (سري)، پر انڊيڪس سان هڪ مخصوص سيل ڏانهن جيڪو هڪ دليل طور آيو آهي. هن معاملي ۾، logarithmic پيچيدگي جي لحاظ کان مختلف ٿيندو جتي ان کي شامل ڪيو ويو آهي:

• جيڪڏهن هي فهرست جي لڳ ڀڳ شروعات هئي، لاگارٿمڪ پيچيدگي O (N) جي ويجهو هوندي، ڇاڪاڻ ته نئين جي ساڄي پاسي واقع سڀني عنصرن کي هڪ سيل کي ساڄي طرف منتقل ڪرڻو پوندو؛
• جيڪڏهن عنصر وچ ۾ داخل ڪيو ويو آهي - O(N/2) ڇاڪاڻ ته اسان کي صرف اڌ فهرست جي عنصرن کي ھڪڙي سيل کي ساڄي طرف منتقل ڪرڻ جي ضرورت آھي.

اهو آهي، هن طريقي جي منطقي پيچيدگي جي حد O (N) کان O (1) تائين منحصر آهي جتي عنصر داخل ڪيو ويو آهي. 2. set(<Index>,<Element>) - هڪ عنصر کي لسٽ ۾ مخصوص پوزيشن ڏانهن لکندو آهي. جيڪڏهن ان پوزيشن تي اڳ ۾ ئي هڪ عنصر موجود آهي، ان کي مٿي لکندو. هن آپريشن جي منطقي پيچيدگي O(1) آهي، ڇاڪاڻ ته اتي ڪا به شفٽ نه آهي: صرف صف ۾ انڊيڪس جي ڳولا، جنهن کي، جيئن اسان کي ياد آهي، O(1) جي پيچيدگي آهي، ۽ عنصر لکڻ. 3. هٽايو (<index>) - هڪ عنصر کي هٽائڻ ان جي انڊيڪس ذريعي اندروني صف ۾. جڏهن هڪ شيءِ کي حذف ڪيو وڃي جيڪا فهرست جي آخر ۾ نه آهي، توهان کي لازمي طور تي سڀني شين کي ان جي ساڄي طرف هڪ سيل کي کاٻي طرف منتقل ڪرڻ گهرجي ته شيون ختم ڪرڻ کان پوءِ ڇڏيل خلا کي بند ڪرڻ لاءِ. تنهن ڪري، logarithmic پيچيدگي ساڳي ٿي ويندي 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) هوندي، ڇاڪاڻ ته صرف آخري عنصر جي لنڪ جي ضرورت آهي، ۽ جيئن توهان کي ياد آهي، دم کي LinkedList کان سڌو سنئون ڳنڍيو ويو آهي ۽ ان تائين رسائي جي لاگارٿمڪ پيچيدگي گهٽ ۾ گهٽ آهي. 2. شامل ڪريو(<Index>,<Element>) - انڊيڪس ذريعي هڪ عنصر شامل ڪرڻ. جڏهن هڪ عنصر شامل ڪيو وڃي، مثال طور، فهرست جي وچ ۾، سر ۽ دم کان عناصر (ٻنهي پاسن تي) پهريون ڀيرو ٻيهر ورجائي رهيا آهن جيستائين گهربل جڳهه نه ملي. جيڪڏهن اسان ٽئين ۽ چوٿين جي وچ ۾ هڪ عنصر داخل ڪرڻ چاهيون ٿا (مٿي ڏنل شڪل ۾)، پوء جڏهن صحيح جڳهه ڳوليندا، ٽئين عنصر جي ايندڙ لنڪ اڳ ۾ ئي نئين هڪ ڏانهن اشارو ڪندي. نئين لاءِ، پوئين لنڪ ٽئين ڏانهن اشارو ڪندي. ان جي مطابق، چوٿين عنصر جو لنڪ - اڳوڻو - اڳ ۾ ئي نئين عنصر ڏانهن اشارو ڪندو، ۽ نئين عنصر جي ايندڙ لنڪ چوٿين عنصر ڏانهن اشارو ڪندي: هن طريقي جي منطقي پيچيدگي نئين عنصر کي ڏنل انڊيڪس تي منحصر هوندي:

• جيڪڏهن اهو سر يا دم جي ويجهو آهي، اهو O(1) جي ويجهو هوندو، ڇاڪاڻ ته اهو اصل ۾ عناصر تي ٻيهر ڪرڻ جي ضرورت نه هوندي؛
• جيڪڏھن اھو وچ جي ويجھو آھي، ته پوءِ O(N/2) - ھيڊ ۽ دم جا عنصر گڏ ڪيا ويندا جيستائين گھربل عنصر ملي وڃي.

3. سيٽ (<Index>،<Element>) - هڪ عنصر کي لسٽ ۾ مخصوص پوزيشن ڏانهن لکندو آهي. هن آپريشن جي منطقي پيچيدگي O(1) کان O(N/2) جي حد تائين هوندي، وري ان تي منحصر آهي ته عنصر سر، دم يا وچ ۾ ڪيترو ويجهو آهي. 4. هٽائي ڇڏيو(<index>) - فهرست مان هڪ عنصر کي هٽائي ٿو، بنيادي طور تي عنصر ٺاهي ٿو جيڪو هڪ هٽائڻ کان اڳ اچي ٿو ( اڳوڻي ) ان عنصر جو حوالو ڏئي ٿو جيڪو هڪ هٽائڻ کان پوء اچي ٿو ( اڳيون ). ۽ ان جي برعڪس: انهي ڪري ته اهو عنصر جيڪو حذف ٿيڻ کان پوءِ اچي ٿو اهو هڪ ڏانهن اشارو ڪري ٿو جيڪو حذف ٿيڻ کان اڳ اچي ٿو: نتيجو انڊيڪس ( add(<Index>,<Element>) ) شامل ڪرڻ لاءِ هڪ عمل آهي. انھن لاءِ جيڪي LinkedList جي اندروني ڍانچي جي باري ۾ وڌيڪ ڄاڻڻ چاھين ٿا ، مان ھن مضمون کي پڙھڻ جي صلاح ڏيان ٿو .

88. HashMap جي اندروني جوڙجڪ ڇا آهي؟

شايد جاوا ڊولپر جي انٽرويو دوران سڀ کان وڌيڪ مشهور سوالن مان هڪ. HashMap v اهم-قدر جوڑوں سان ڪم ڪري ٿو . اهي پاڻ HashMapv اندر ڪيئن محفوظ ٿيل آهن ؟ HashMap جي اندر اندر نوڊس جو هڪ صف آهي:

Node<K,V>[] table

ڊفالٽ طور، صف جي سائيز 16 آھي، ۽ اھو ھر دفعي ٻيڻو ٿي ويندو آھي جيئن اھو عناصرن سان ڀريو ويندو آھي (جڏھن LOAD_FACTOR پھچي ويندو آھي - ھڪڙي خاص فيصد پوريءَ جو، ڊفالٽ طور اھو آھي 0.75 ). هر نوڊ ڪيئي جي هڪ هيش، هڪ ڪي، هڪ قدر، ۽ ايندڙ عنصر جي هڪ لنڪ کي محفوظ ڪري ٿو: دراصل، "اڳتي عنصر سان ڳنڍڻ" جو مطلب آهي ته اسان هڪ واحد ڳنڍيل فهرست سان ڪم ڪري رهيا آهيون، جتي هر عنصر هڪ لنڪ تي مشتمل آهي. ايندڙ. اھو آھي، HashMap ھڪڙي ھڪڙي ڳنڍيل فهرستن جي ھڪڙي صف ۾ ڊيٽا کي ذخيرو ڪري ٿو. پر مان فوري طور تي نوٽ ڪندس: جڏهن ٽيبل صف جي هڪ سيل ۾ هڪ جهڙي طرح سان ڳنڍيل فهرست جي هڪ ڪڙي آهي جنهن ۾ هڪ کان وڌيڪ عنصر شامل آهن، اهو سٺو ناهي. هن رجحان کي تصادم سڏيو ويندو آهي . پر پهرين شيون پهرين. اچو ته ڏسو ته ڪيئن هڪ نئون جوڙو محفوظ ڪيو ويو آهي put method استعمال ڪندي . پهريون، هيچ ڪوڊ () چاٻي جو ورتو ويو آهي. تنهن ڪري، hashmap صحيح طريقي سان ڪم ڪرڻ لاءِ ، توهان کي ڪلاس وٺڻ گهرجن جن ۾ هي طريقو ڪنجي جي طور تي ختم ڪيو ويو آهي. هي هيش ڪوڊ پوءِ اندروني طريقي ۾ استعمال ڪيو ويندو آهي - hash() - ٽيبل صف جي سائيز ۾ نمبر کي طئي ڪرڻ لاءِ . اڳيون، حاصل ڪيل نمبر استعمال ڪندي، ٽيبل جي ھڪڙي مخصوص سيل تائين پھچايو ويو آھي . هتي اسان وٽ ٻه ڪيس آهن:

1. سيل خالي آهي - نئين نوڊ قدر ان ۾ ذخيرو ٿيل آهي .
2. سيل خالي نه آهي - ڪنجين جي قيمت جي مقابلي ۾ آهي. جيڪڏهن اهي برابر آهن، نئين نوڊ جي قيمت پراڻي هڪ مٿان لکندو آهي، جيڪڏهن اهي برابر نه آهن، ايندڙ عنصر تائين رسائي حاصل ڪئي ويندي آهي ۽ ان جي چاٻي سان مقابلو ڪيو ويندو آهي ... ۽ ائين ئي جيستائين نئين قيمت ڪجهه پراڻي هڪ کي مٿي ڪري ٿو يا ان جي آخر تائين پهچي ٿو. اڪيلو ڳنڍيل فهرست ۽ اتي ذخيرو ڪيو ويندو آخري عنصر طور.

جڏهن هڪ عنصر کي key ( get(<key>) طريقي سان ڳولهيو وڃي ٿو ، ته ڪيڏي جو hashCode ڳڻيو ويندو آهي، پوءِ ان جي قيمت array جي اندر hash() استعمال ڪندي، ۽ نتيجو نمبر استعمال ڪندي، ٽيبل جي صف جو سيل مليو آهي. ، جنهن ۾ ڳولها اڳ ۾ ئي نوڊس جي ڳڻپ ڪندي ڪئي وئي آهي ۽ گهربل نوڊ جي ڪنجي کي موجوده هڪ جي ڪنجي سان ڀيٽيو. نقشي ۾ آپريشنز ، مثالي صورتحال ۾، O(1) جي الگورتھمڪ پيچيدگي آھي، ڇاڪاڻ⁠تہ اھي ھڪڙي صف تائين پھچائي رھيا آھن، ۽ جيئن توھان کي ياد آھي، عناصرن جي تعداد کان سواءِ، ھڪ صف تي عملن ۾ O(1) جي پيچيدگي آھي. . پر هي مثالي آهي. جڏهن سري سيل استعمال ڪيو پيو وڃي ته خالي نه آهي (2) ۽ اتي اڳ ۾ ئي ڪجهه نوڊس موجود آهن، الورورٿمڪ پيچيدگي لڪير O (N) ۾ تبديل ٿي ويندي آهي، ڇاڪاڻ ته هاڻي اهو ضروري آهي ته صحيح جڳهه ڳولڻ کان اڳ عناصر تي ٻيهر ورجائي. مان مدد نه ٿو ڪري سگهان پر هن جو ذڪر: جاوا 8 سان شروع ڪندي، جيڪڏهن هڪ اڪيلو ڳنڍيل لسٽ نوڊ ۾ 8 عنصرن (ٽڪر) کان وڌيڪ آهن، اهو هڪ بائنري وڻ ۾ بدلجي ٿو. انهي صورت ۾، الورورٿمڪ پيچيدگي هاڻي O (N) نه هوندي، پر O (log (N)) - اهو هڪ ٻيو معاملو آهي، ڇا اهو ناهي؟ HashMap ھڪڙو وڏو موضوع آھي، ۽ ماڻھو پسند ڪندا آھن انٽرويو ۾ ان بابت سوال پڇڻ. تنهن ڪري، مان توهان کي صلاح ڏيان ٿو ته ان کي تفصيل سان سمجھو (جيئن ته اهو توهان جي ڏند کي ڦٽو ڪري). ذاتي طور تي، مون کي HashMap سوالن کان سواء هڪ انٽرويو نه ڪيو آهي . توهان هن مضمون ۾ HashMap ۾ هڪ گہرے غوطه ڳولي سگهو ٿا . اهو سڀ ڪجهه اڄ تائين آهي، جاري رکڻ لاءِ...