اهي هڪ انٽرويو ۾ ڇا پڇي سگھن ٿا: جاوا ۾ ڊيٽا جي جوڙجڪ. حصو 2

حصو 1 ھاڻي اسان ان بنياد جي باري ۾ ڳالھائي رھيا آھيون جيڪو ھر جاوا ڊولپر کي ڄاڻڻ گھرجي. انهيءَ ڪلاسيڪل علم جي باري ۾ جنهن کان اهو سڀ شروع ٿئي ٿو. اڄ مان ڪنهن به انٽرويو جي بنيادي موضوعن مان هڪ تي رابطو ڪرڻ چاهيندس - جاوا ۾ ڊيٽا جي جوڙجڪ . تنهن ڪري، ٻڪرين جي چوڌاري مارڻ بدران، اچو ته شروع ڪريون. سوالن جي لسٽ جي تسلسل کي پڪڙيو جيڪي توھان ھن موضوع تي ھڪ انٽرويو دوران پڇيا ويندا.

6. اسان کي لسٽ بابت ٻڌايو

لسٽ هڪ انٽرفيس آهي جيڪو شين جي ترتيب ڏنل ساخت جي نمائندگي ڪري ٿو، جنهن کي فهرست سڏيو ويندو آهي. هن ڍانچي جي ”چال“ اها آهي ته لسٽ ۾ شامل عنصرن کي انڊيڪس ذريعي داخل، تبديل يا حذف ڪري سگهجي ٿو، يعني لسٽ جو اندروني سڃاڻپ ڪندڙ . ٻين لفظن ۾، انڊيڪس جو مطلب آهي: "ڪيترا عنصر فهرست جي شروعات کان آهن." پهرين لسٽ عنصر ۾ انڊيڪس 0 آهي، ٻئي ۾ انڊيڪس 1 آهي، وغيره. تنهن ڪري پنجون عنصر فهرست جي شروعات کان چار عنصر پري آهي. جيئن مٿي ذڪر ڪيو ويو آهي، ترتيب جنهن ۾ شيون شامل ڪيون ويون آهن هڪ فهرست ۾ اهم آهي. انهي ڪري ڊيٽا جي جوڙجڪ کي فهرست سڏيو ويندو آهي . اسان هن ڍانچي لاءِ منفرد طريقن جي فهرست ڏيون ٿا جن جو مقصد عنصرن سان ڪم ڪرڻ آهي اشاري سان:

• حاصل ڪريو - عنصر کي مخصوص پوزيشن تي موٽائي ٿو (انڊيڪس ويليو طرفان)،
• هٽايو - مخصوص پوزيشن تي عنصر کي هٽائي ٿو،
• سيٽ - مخصوص پوزيشن تي عنصر کي تبديل ڪري ٿو طريقي سان بيان ڪيل عنصر سان.

مکيه عمل آهن ArrayList ۽ LinkedList . اسان ٿوري دير کان پوء انھن جي باري ۾ وڌيڪ ڳالهائي ويندي. ویکٹر هڪ فهرست آهي جيڪا ٿريڊ-محفوظ آهي، تنهنڪري هن طبقي ۾ هر طريقو هم وقت سازي آهي. پر ذهن ۾ رکو ته جيڪڏهن توهان ڪجهه فهرستن جي عملن کي محفوظ ڪرڻ چاهيو ٿا، ته توهان عملن جي پوري ترتيب کي هم وقت سازي ڪندا. ۽ انفرادي عملن کي هم وقت سازي ڪرڻ گهٽ محفوظ ۽ تمام سست آهي. يقينن، ویکٹر وٽ به لاڪنگ اوور هيڊ آهي، جيتوڻيڪ توهان کي تالا جي ضرورت نه آهي. تنهن ڪري، هي طبقو هاڻي متروڪ سمجهيو ويندو آهي ۽ استعمال نه ڪيو ويندو آهي. رستي ۾: ArrayList Vector سان ملندڙ جلندڙ آهي ، پر تالا استعمال نه ڪندو آهي، تنهنڪري اهو هر جڳهه استعمال ڪيو ويندو آهي. اسٽيڪ ویکٹر ڪلاس جو ھڪڙو ذيلي ڪلاس آھي ھڪڙي ڊفالٽ ٺاھيندڙ سان ۽ ویکٹر ڪلاس جا سڀ طريقا ، ان سان گڏ ڪجھ پنھنجون (اسان انھن بابت بعد ۾ ڳالهائينداسين). مثال طور، توھان تصور ڪري سگھو ٿا عمل کي دستاويزن سان فولڊر جي اسٽيڪ جي طور تي. توهان هڪ فولڊر کي اسٽيڪ جي چوٽي تي رکو ٿا، ۽ توهان صرف انهن فولڊر کي ريورس آرڊر ۾ وٺي سگهو ٿا، مٿين کان شروع ڪندي. دراصل، هي هڪ LIFO قسم جو ميڪانيزم آهي ، اهو آهي، Last In First Out ، آخري جيڪو اچڻو آهي اهو سڀ کان پهرين ڇڏڻ وارو آهي. اسٽيڪ پنهنجي طريقن کي لاڳو ڪري ٿو:

• push - منظور ٿيل عنصر شامل ڪري ٿو اسٽيڪ جي چوٽي تي؛
• peek - عنصر کي واپس ڏئي ٿو جيڪو اسٽيڪ جي چوٽي تي آهي؛
• پاپ - اهو عنصر پڻ واپس ڪري ٿو جيڪو اسٽيڪ جي چوٽي تي آهي، پر ان کي هٽائي ٿو؛
• خالي - چيڪ ڪري ٿو ته ڇا اسٽيڪ خالي آهي - صحيح يا نه - غلط ؛
• ڳولا - ڏنل عنصر جي اسٽيڪ کي ڳولي ٿو. جيڪڏهن هڪ عنصر مليو آهي، ان جي ترتيب نمبر اسٽيڪ جي چوٽي سان لاڳاپيل آهي. جيڪڏهن عنصر نه مليو آهي، قيمت -1 واپسي آهي.

هن وقت، اسٽيڪ ذيلي ڪلاس اصل ۾ استعمال نه ڪيو ويو آهي ان جي سادگي ۽ لچڪ جي ڪري، پر، ان جي باوجود، توهان ان سان منهن ڏئي سگهو ٿا. مثال طور، جڏهن توهان ڪجهه غلطي وصول ڪندا آهيو ۽ ڪنسول ۾ توهان ان بابت پيغامن جو اسٽيڪ ڏسو. توهان هن مضمون ۾ اسٽيڪ ۽ قطار بابت وڌيڪ پڙهي سگهو ٿا .

7. اسان کي نقشي بابت ٻڌايو

جيئن مٿي بيان ڪيو ويو آهي، هڪ نقشو هڪ مجموعو آهي جنهن ۾ انٽرفيس ۽ انهن تي عمل ڪرڻ جو هڪ الڳ ڍانچو هوندو آهي. اهو الڳ آهي ڇاڪاڻ ته هتي قيمتون هڪ وقت ۾ ذخيرو ٿيل نه آهن، پر هڪ "اهم-قدر" جوڙي ۾. بنيادي نقشي جا طريقا :

• put(K key، V value) - نقشي ۾ عنصر شامل ڪرڻ؛
• حاصل ڪريو (آبجڪٽ ڪيچ) - چاٻي ذريعي قدر جي ڳولا ڪريو؛
• containsKey(Object key) — هن ڪيئي جي موجودگيءَ لاءِ نقشي کي چيڪ ڪري ٿو؛
• containsValue(Object value) - ھن قدر جي موجودگي لاءِ نقشي کي چيڪ ڪري ٿو؛
• هٽايو (آبجڪٽ ڪيئي) - هڪ قدر کي هٽائڻ ان جي ڪنجي ذريعي.

جئين توهان ڏسي سگهو ٿا، سڀ کان وڌيڪ آپريشن ڪنجي استعمال ڪندي ڪم ڪن ٿا. ضابطي جي طور تي، غير تبديل ٿيندڙ شيون چونڊيل آهن چابيون . هن اعتراض جو هڪ عام مثال آهي String . بنيادي نقشي تي عمل ڪرڻ :

1. HashMap - بي ترتيب ترتيب ۾ قدرن کي ذخيرو ڪرڻ لاءِ ٺهيل آهي، پر توهان کي جلدي نقشي جي عناصر کي ڳولڻ جي اجازت ڏئي ٿي. توھان کي اجازت ڏئي ٿو ته null keyword استعمال ڪندي ڪيچي بيان ڪريو ، پر ھڪ دفعو کان وڌيڪ نه، ڇاڪاڻ ته ساڳيون چابيون سان جوڙو هڪ ٻئي جي مٿي تي لکيل آهن. مکيه شرط چابمن جي انفراديت آهي: قدرن کي بار بار ڪري سگهجي ٿو (ڪيترن ئي null قدر ٿي سگهي ٿو).
2. LinkedHashMap HashMap جو ھڪڙو اينالاگ آھي جيڪو قدرن کي ترتيب ۾ رکي ٿو انھن کي شامل ڪيو ويو آھي. ان جي مطابق، LinkedList وانگر ، اهو هڪ هيڊر آهي - هڪ ٻيڻو ڳنڍيل فهرست جو سر. جڏهن شروعات ڪئي وئي، اهو پاڻ ڏانهن اشارو ڪري ٿو.

   LinkedHashMap وٽ هڪ رسائي آرڊر پڻ آهي جيڪو بيان ڪري ٿو ته عناصر ڪيئن پهچندا جڏهن آئٽرٽر استعمال ڪيو ويندو. جيڪڏهن رسائي آرڊر غلط آهي ، رسائي ان ترتيب ۾ ڪئي ويندي جيڪا عناصر داخل ڪيا ويا هئا. جيڪڏهن صحيح، عناصر آخري پهچ جي ترتيب ۾ هوندا (آخري پهچايل عنصر آخر ۾ رکيا ويندا).

3. TreeMap ھڪڙو نقشو آھي جيڪو عناصر کي مکيه قدرن سان ترتيب ڏئي ٿو. TreeSet سان ملندڙ جلندڙ ، پر جوڑوں لاءِ بنيادي قدرن جي بنياد تي. TreeMap ترتيب ڏيڻ جا قاعدا مقرر ڪرڻ لاءِ ، ڪن کي لازمي انٽرفيس لاڳو ڪرڻ گھرجي . ٻي صورت ۾، اتي هجڻ گهرجي هڪ اهم-مقابلي ڪندڙ (جيڪو بيان ڪيو ويو آهي TreeMap constructor ) ۾، هڪ TreeSet - اندر اندر TreeMap اعتراض سان لاڳو ڪيو ويو آهي، جنهن ۾، حقيقت ۾، سڀ جادو ٿئي ٿو.

   توھان وڌيڪ پڙھي سگھو ٿا TreeMap ۾ ترتيب ڏيڻ بابت ڳاڙھو-ڪارو وڻ استعمال ڪندي مضمون ۾ TreeMap جي خاصيتن بابت .

4. Hashtable HashMap سان ملندڙ جلندڙ آهي ، پر null کي يا ته ڪنجي يا قدر جي طور تي ذخيرو ٿيڻ جي اجازت نه ڏيندو آهي . اهو احتياط سان هم وقت سازي ڪيو ويو آهي ملٽي ٿريڊنگ نقطي نظر کان، جنهن جو مطلب اهو آهي ته اهو هڪ گهڻ ٿريڊنگ نقطي نظر کان محفوظ آهي. پر اهو عمل پراڻو ۽ سست آهي، تنهنڪري هاڻي توهان نه ڏسندا هيشٽبل وڌيڪ يا گهٽ نون منصوبن ۾.

8. ArrayList بمقابلہ LinkedList. ڪهڙو استعمال ڪرڻ بهتر آهي؟

اهو سوال شايد ڊيٽا جي جوڙجڪ تي تمام گهڻو مشهور آهي ۽ ان سان گڏ ڪجهه نقصانات آهي. ان جو جواب ڏيڻ کان پهريان، اچو ته انهن ڊيٽا جي جوڙجڪ بابت وڌيڪ ڄاڻون. ArrayList لسٽ انٽرفيس کي لاڳو ڪري ٿو ۽ اندروني صف تي هلندي آهي جيڪا ضرورت مطابق وڌايو وڃي. جڏهن اندروني صف مڪمل طور تي ڀريو وڃي ٿو، ۽ هڪ نئون عنصر داخل ٿيڻ جي ضرورت آهي، هڪ نئين صف ٺاهي وئي آهي جنهن جي سائيز (پراڻي سائز * 1.5) +1 سان. ان کان پوء، پراڻي صف مان سڀ ڊيٽا نئين + نئين عنصر ڏانهن نقل ڪئي وئي آهي، ۽ پراڻي هڪ کي رد ڪيو ويندو ردي جي ڪليڪٽر طرفان . شامل ڪرڻ جو طريقو صف جي آخري خالي سيل ۾ هڪ عنصر شامل ڪري ٿو. اهو آهي، جيڪڏهن اسان وٽ اڳ ۾ ئي 3 عنصر آهن، اهو ايندڙ هڪ کي 4th سيل ۾ شامل ڪندو. اچو ته بنيادي طريقن جي ڪارڪردگي جي ذريعي وڃو:

• get(int index) - انڊيڪس جي ترتيب ۾ هڪ عنصر کڻڻ O(1) ۾ تيز ترين آهي ؛
• add(Object obj) - جيڪڏهن نئين عنصر لاءِ اندروني صف ۾ ڪافي جاءِ آهي، ته پوءِ عام داخل ڪرڻ سان O(1) وقت خرچ ڪيو ويندو ، ڇاڪاڻ ته اضافو آخري سيل ڏانهن نشانو بڻايو ويو آهي.

  جيڪڏهن اسان کي هڪ نئين سر ٺاهڻ جي ضرورت آهي ۽ ان ۾ مواد کي نقل ڪرڻ جي ضرورت آهي، ته پوء اسان جو وقت صف ۾ عناصر جي تعداد جي سڌي طرح متناسب هوندو O (n) ؛

• هٽايو (int index) - جڏهن هڪ عنصر کي هٽايو، مثال طور، وچ مان، اسان کي O (n/2) وقت ملندو، ڇو ته اسان کي عناصر کي ان جي ساڄي طرف هڪ سيل واپس منتقل ڪرڻو پوندو. ان جي مطابق، جيڪڏهن فهرست جي شروعات کان حذف ڪيو وڃي، پوء O (n)، آخر کان - O(1)؛
• add(int index, Object obj) - ھڪڙي صورتحال کي ختم ڪرڻ جھڙي آھي: وچ ۾ شامل ڪرڻ وقت، اسان کي عناصر کي ساڄي ھڪڙي سيل ڏانھن اڳتي وڌڻ جي ضرورت پوندي، تنھنڪري وقت آھي O (n/2). يقينا، شروعات کان - O (n)، آخر کان - O (1)؛
• set(int index, Object obj) - هتي صورتحال مختلف آهي، ڇو ته توهان کي صرف گهربل عنصر ڳولڻ جي ضرورت آهي ۽ ان تي لکڻ جي ضرورت آهي باقي حرڪت کان سواء، تنهنڪري O(1).

هن مضمون ۾ ArrayList بابت وڌيڪ پڙهو . LinkedList هڪ ئي وقت ۾ ٻه انٽرفيس لاڳو ڪري ٿو - List ۽ Queue ، ۽ ان ڪري ٻنهي ڊيٽا جي جوڙجڪ ۾ خاصيتون ۽ طريقا شامل آهن. لسٽ مان هن انڊيڪس ذريعي هڪ عنصر تائين رسائي حاصل ڪئي، قطار مان - هڪ "سر" ۽ "دم" جي موجودگي. اندروني طور تي، اهو هڪ ڊيٽا جي جوڙجڪ جي طور تي لاڳو ڪيو ويو آهي جيڪو ٻه ڀيرا ڳنڍيل فهرست جي نمائندگي ڪري ٿو. اهو آهي، هر عنصر کي ايندڙ ۽ پوئين هڪ سان ڳنڍيل آهي، سواء "دم" ۽ "سر" جي.

• get(int index) - جڏهن فهرست جي وچ ۾ هڪ عنصر جي ڳولا ڪريو، اهو سڀني عناصر جي ترتيب سان ڳولڻ شروع ڪري ٿو جيستائين گهربل هڪ نه ملي. منطقي طور تي، ڳولها وٺڻ گهرجي O(n/2) ، پر LinkedList ۾ پڻ هڪ دم آهي، تنهنڪري ڳولا ٻنهي پاسن کان گڏ ڪئي ويندي آهي. ان مطابق، وقت گھٽجي ويو آھي O(n/4) .

  جيڪڏهن عنصر فهرست جي شروعات يا آخر جي ويجهو آهي، پوء وقت ٿيندو O(1) ؛

• add(Object obj) - جڏهن نئون عنصر شامل ڪيو ويندو، "دم" عنصر کي ايندڙ عنصر جي لنڪ هوندي، ۽ نئين کي هن پوئين عنصر جي لنڪ ملندي ۽ نئين "دم" بڻجي ويندي. ان مطابق، وقت ٿيندو O(1) ؛
• هٽايو (int index) - حاصل (int index) طريقي سان ملندڙ منطق . فهرست جي وچ مان هڪ عنصر کي هٽائڻ لاء، توهان کي پهريان ان کي ڳولڻ گهرجي. اهو وري آهي O(n/4) ، جڏهن ته حذف ڪرڻ خود اصل ۾ ڪجهه به نه وٺندو آهي، ڇاڪاڻ ته اهو صرف پاڙيسري شين جي پوائنٽر کي تبديل ڪري ٿو (اهي هڪ ٻئي ڏانهن اشارو ڪرڻ شروع ڪن ٿا). جيڪڏهن عنصر شروع ۾ يا آخر ۾ آهي، ته پوء ٻيهر - O(1) ؛
• add(int index, Object obj) and set(int index, Object obj) - طريقن کي حاصل ڪرڻ لاءِ وقت جي پيچيدگي هڪجهڙائي هوندي (int index) ، ڇاڪاڻ ته گهڻو وقت عنصر جي ڳولا ۾ گذاريو ويندو آهي. تنهن ڪري، فهرست جي وچ ۾ - O(n/4) ، شروعات لاءِ - O(1).

LinkedList سان ڪم ڪرڻ بابت وڌيڪ معلومات هن مضمون ۾ بيان ڪئي وئي آهي . اچو ته هي سڀ هڪ ٽيبل ۾ ڏسو: جيئن ته توهان شايد اڳ ۾ ئي سمجهي، ان سوال جو جواب ڏيڻ ناممڪن آهي. آخرڪار، مختلف حالتن ۾ اهي مختلف رفتار تي ڪم ڪن ٿا. تنهن ڪري، جڏهن توهان هن طرح هڪ سوال پڇيو آهي، توهان کي فوري طور تي پڇڻ گهرجي ته هي فهرست ڇا تي مرکوز ڪيو ويندو ۽ ڪهڙيون آپريشنون اڪثر ڪيون وينديون آهن. ان کان شروع ڪري، جواب ڏيو، پر وضاحت سان ته ائين ڇو آهي. اچو ته اسان جي مقابلي کي اختصار ڪريون: ArrayList:

• بهترين انتخاب جيڪڏهن سڀ کان وڌيڪ بار بار آپريشن هڪ عنصر جي ڳولا ڪري رهيو آهي، هڪ عنصر کي ختم ڪري رهيو آهي؛
• بدترين انتخاب جيڪڏهن آپريشن آهي داخل ڪرڻ ۽ ختم ڪرڻ جي شروعات-وچ ۾، ڇاڪاڻ ته ساڄي پاسي عناصر جي شفٽ آپريشن ٿيندي.

ڳنڍيل لسٽ:

• بهترين انتخاب جيڪڏهن اسان جو بار بار آپريشن آهي داخل ڪرڻ ۽ ختم ڪرڻ جي شروعات وچ ۾؛
• بدترين انتخاب جيڪڏهن سڀ کان وڌيڪ عام آپريشن ڳولا آهي.

9. HashMap ۾ عناصر ڪيئن ذخيرو ٿيل آهن؟

HashMap گڏ ڪرڻ ۾ هڪ اندروني صف شامل آهي Node[] جدول ، جنهن جي سيلن کي بڪيٽ پڻ سڏيو ويندو آهي . نوڊ تي مشتمل آهي:

• چاٻي - ڪنجي سان ڳنڍڻ،
• قدر- قدر جو حوالو،
• hash - hash value
• ايندڙ - ايندڙ نوڊ ڏانهن لنڪ .

ٽيبل جي هڪ سيل [] صف ۾ شايد نوڊ آبجیکٹ جو حوالو هجي جنهن ۾ ايندڙ نوڊ عنصر جي لنڪ هجي، ۽ ٿي سگهي ٿي ان ۾ ڪنهن ٻئي سان ڪڙي هجي، وغيره وغيره... نتيجي طور، اهي نوڊ عنصر ٺاهي سگهن ٿا . اڪيلو ڳنڍيل فهرست ، عناصر سان گڏ ايندڙ لنڪ سان. هن معاملي ۾، هڪ زنجير جي عنصرن جي hash قدر ساڳيو آهي. هڪ مختصر تحرير کان پوءِ، اچو ته ڏسون ته عناصر ڪيئن ذخيرو ٿيل آهن HashMap ۾ :

1. null لاء چيڪ ڪيو ويو آهي . جيڪڏهن اهو null آهي ته پوءِ ڪيئي کي ٽيبل[0] سيل ۾ محفوظ ڪيو ويندو ڇاڪاڻ ته null لاءِ هيش ڪوڊ هميشه 0 هوندو آهي.
2. جيڪڏهن ڪيچي null نه آهي ، ته پوء اهم اعتراض جي hashcode() طريقو سڏيو ويندو آهي ، جيڪو ان جو هيش ڪوڊ واپس ڪندو. هي هيش ڪوڊ استعمال ڪيو ويندو آهي سري سيل کي طئي ڪرڻ لاءِ جتي نوڊ اعتراض محفوظ ڪيو ويندو.
3. اڳيون، هي هيش ڪوڊ اندروني hash() طريقي ۾ رکيل آهي ، جيڪو حساب ڪري ٿو hashcode، پر ٽيبل جي سائيز جي اندر [] array .
4. اڳيون، هيش ويليو تي منحصر ڪري، نوڊ ٽيبل[] صف ۾ هڪ مخصوص سيل ۾ رکيل آهي .
5. جيڪڏهن ٽيبل[] سيل موجوده نوڊ عنصر کي محفوظ ڪرڻ لاءِ استعمال ڪيو ويندو آهي، خالي نه آهي، پر اڳ ۾ ئي ڪجهه عنصر آهي، پوء نوڊ عناصر کي ايندڙ قيمت تي بار بار ڪيو ويندو جيستائين آخري عنصر پهچي وڃي. اهو آهي، جنهن جو ايندڙ ميدان null آهي .

   هن ڳولا دوران، محفوظ ٿيل نوڊ اعتراض جي ڪنجي جو مقابلو ڪيو ويو آهي انهن جي چاٻين سان جيڪي ڳولي رهيا آهن:

   • جيڪڏهن هڪ ميچ مليو آهي، ڳولا ختم ٿي ويندي، ۽ نئون نوڊ ان نوڊ کي مٿي ڪري ڇڏيندو جنهن ۾ ميچ مليو هو (صرف ان جي قيمت واري فيلڊ کي اوور رائٽ ڪيو ويندو )؛
   • جيڪڏهن ڪي اهم ميچ نه مليا آهن، ته نئون نوڊ هن لسٽ ۾ آخري بڻجي ويندو، ۽ پوئين هڪ کي ان جي اڳيان لنڪ هوندي.

سوال اڪثر انٽرويو دوران اچي ٿو: تڪرار ڇا آهي ؟ اها صورتحال جڏهن ٽيبل[] آري جي سيل ۾ هڪ عنصر نه، پر ٻن يا وڌيڪ جي زنجير کي ذخيرو ڪيو وڃي، ان کي ٽڪراءُ چئبو آهي . عام حالتن ۾ جتي صرف هڪ عنصر هڪ واحد ٽيبل[] سيل ۾ ذخيرو ٿيل آهي، HashMap جي عناصر تائين رسائي مسلسل O(1) وقت جي پيچيدگي آهي . پر جڏهن گهربل عنصر سان سيل ۾ عنصرن جي هڪ زنجير شامل آهي ( تصادم )، پوء O (n) ، ڇاڪاڻ ته هن صورت ۾ وقت سڌو سنئون ترتيب ڏنل عناصر جي تعداد سان متناسب آهي.

10. بيان ڪندڙ کي بيان ڪريو

مٿي ڏنل ڪليڪشن هيرارڪي ميپنگ آريگرام ۾ ، ڪليڪشن انٽرفيس اهو هو جتي پوري درجه بندي شروع ٿي هئي، پر عملي طور تي اهو بلڪل اهڙو ناهي. ڪليڪشن هڪ انٽرفيس مان ورثي ۾ ملي ٿو iterator() طريقي سان ، جيڪو هڪ اعتراض ڏي ٿو جيڪو لاڳو ڪري ٿو Iterator<E> انٽرفيس . Iterator انٽرفيس هن طرح ڏسڻ ۾ اچي ٿو:

public interface Iterator <E>{

    E next();
    boolean hasNext();
    void remove();
}

next() - هن طريقي کي ڪال ڪندي، توهان حاصل ڪري سگهو ٿا ايندڙ عنصر. hasNext() - توهان کي اهو معلوم ڪرڻ جي اجازت ڏئي ٿو ته ڇا ايندڙ عنصر آهي، ۽ ڇا گڏ ڪرڻ جي پڄاڻي تي پهچي ويو آهي. ۽ جڏهن اڃا به عناصر موجود آهن، hasNext() موٽي ويندو true . عام طور تي، hasNext() کي ايندڙ () طريقي کان اڳ سڏيو ويندو آهي ، ڇاڪاڻ ته next() هڪ NoSuchElementException اڇلائي ڇڏيندو جڏهن اهو مجموعي جي آخر تائين پهچندو . remove() - ان عنصر کي هٽائي ٿو جيڪو آخري ڪال ذريعي حاصل ڪيو ويو ايندڙ () ڏانهن . Iterator جو مقصد عناصرن کي ٻيهر ڏيڻ آهي. مثال طور:

Set<Integer> values = new TreeSet<>();
  values.add(5);
values.add(3);
values.add(6);
values.add(8);
values.add(2);
values.add(4);
values.add(1);
values.add(7);

Iterator<Integer> iter = values.iterator();
while(iter.hasNext()){
  System.out.println(iter.next());
}

دراصل، ھر ھڪ لوپ لاءِ ھود جي ھيٺان لاڳو ڪيو ويندو آھي ھڪ آئٽرٽر استعمال ڪندي. توھان ھن بابت وڌيڪ پڙھي سگھوٿا هتي . لسٽ هڪ آئٽرٽر جو پنهنجو نسخو مهيا ڪري ٿو، پر هڪ ٿڌو ۽ وڌيڪ نفيس هڪ - ListIterator . هي انٽرفيس وڌائي ٿو Iterator ۽ اضافي طريقا آهن:

• hasPrevious صحيح موٽندو جيڪڏھن مجموعي ۾ اڳوڻو عنصر آھي، ٻي صورت ۾ غلط؛
• اڳوڻو موجوده عنصر کي واپس ڏئي ٿو ۽ پوئين ھڪڙي ڏانھن ھلندو آھي؛ جيڪڏهن ڪو به ناهي، پوء هڪ NoSuchElementException اڇلايو ويندو آهي؛
• شامل ڪيو ويندو داخل ڪيو ويو پاس ٿيل اعتراض ان کان اڳ جو عنصر کي واپس ڪيو وڃي ايندڙ ڪال ذريعي next() ؛
• سيٽ موجوده عنصر کي منظور ٿيل اعتراض جو حوالو ڏئي ٿو؛
• nextIndex ايندڙ عنصر جي انڊيڪس واپسي. جيڪڏهن اهڙي ڪا به شيء نه آهي، پوء فهرست جي سائيز واپس ڪئي وئي آهي؛
• اڳوڻو انڊيڪس پوئين عنصر جي انڊيڪس کي واپس ڪري ٿو. جيڪڏهن ڪو به نه آهي، پوء نمبر -1 موٽيو ويندو.

خير، اهو سڀ ڪجهه اڄ مون لاء آهي. مون کي اميد آهي ته هن مضمون پڙهڻ کان پوء توهان اڃا به وڌيڪ ويجھو آهن توهان جي پياري خواب - هڪ ڊولپر ٿيڻ لاء.