جاوا قطار انٽرفيس ۽ ان تي عمل درآمد

هتي اسان جاوا قطار انٽرفيس تي بحث ڪرڻ وارا آهيون. توھان کي معلوم ٿيندو ته قطار جي ڊيٽا جي جوڙجڪ ڇا آھي، جاوا ۾ اھو ڪيئن ظاھر ڪيو ويو آھي، ڪھڙا طريقا سڀني قطارن لاءِ سڀ کان وڌيڪ اھم آھن. پڻ، جاوا ٻولي ۾ قطار جا ڪهڙا عمل آهن. ان کان پوء، اسان سڀ کان وڌيڪ اهم عملن تي هڪ ويجهي نظر رکون ٿا ۽ انهن کي مثالن سان سکندا آهيون.

قطار ڊيٽا جي جوڙجڪ

هڪ قطار هڪ لڪير خلاصي ڊيٽا جو ڍانچو آهي جنهن سان عمل ڪرڻ جي خاص ترتيب سان آهي - فرسٽ ان فرسٽ آئوٽ (FIFO). ان جو مطلب اهو آهي ته توهان هڪ عنصر شامل ڪري سگهو ٿا (يا قطار، قطار ۾ وجهي) صرف ساخت جي آخر ۾، ۽ هڪ عنصر وٺي سگهو ٿا (قطار کان هٽايو يا قطار مان) صرف ان جي شروعات کان. توھان تصور ڪري سگھو ٿا قطار ڊيٽا جي جوڙجڪ بلڪل آساني سان. اهو لڳي ٿو هڪ قطار يا حقيقي زندگي ۾ گراهڪن جي هڪ قطار. گراهڪ جيڪو پهريون آيو، ان کي پڻ پهرين خدمت ڪئي ويندي. جيڪڏهن توهان وٽ McDonalds يا ٻي جاءِ تي چار ماڻهو قطار ۾ آهن، پهرين قطار ۾ بيهڻ وارو پهريون هوندو جيڪو اسٽور حاصل ڪرڻ لاءِ پهريون هوندو. جيڪڏهن نئون گراهڪ ايندو، ته هو هيمبرگر حاصل ڪرڻ لاءِ قطار ۾ پنجين نمبر تي هوندو. تنهن ڪري، قطار سان ڪم ڪرڻ دوران، نوان عنصر شامل ڪيا ويا آهن، ۽ جيڪڏهن توهان هڪ عنصر حاصل ڪرڻ چاهيو ٿا، اهو شروع کان ورتو ويندو. هي ڪلاسيڪل قطار ڊيٽا جي جوڙجڪ جي ڪم جو بنيادي اصول آهي.

جاوا ۾ قطار

جاوا ۾ قطار هڪ انٽرفيس آهي. Oracle دستاويزن جي مطابق، قطار انٽرفيس ۾ 2 سپر انٽرفيس، 4 مختلف انٽرفيس جيڪي قطار مان ورثي ۾ ملن ٿا، ۽ طبقن جي هڪ انتهائي متاثر ڪندڙ فهرست. هن جو ڇا مطلب آهي؟ سڀ کان پهريان، جاوا قطار جمع ڪرڻ واري فريم ورڪ جو حصو آهي ۽ گڏ ڪرڻ واري انٽرفيس کي لاڳو ڪري ٿو. تنهن ڪري اهو ڪليڪشن انٽرفيس جي سڀني طريقن کي سپورٽ ڪري ٿو جهڙوڪ داخل ڪرڻ، حذف ڪرڻ وغيره. قطار لاڳو ڪري ٿو Iterable انٽرفيس، جيڪو هڪ اعتراض کي "هر لوپ لاء" بيان جو نشانو بڻائڻ جي اجازت ڏئي ٿو.

قطار جا طريقا جاوا

قطار ڪيترن ئي طريقن جو اعلان ڪري ٿو. انٽرفيس جي طريقن جي طور تي انهن کي سڀني طبقن ۾ نمائندگي ڪرڻ گهرجي جيڪي قطار کي لاڳو ڪن ٿا. سڀ کان اهم قطار جا طريقا، جاوا:

• Boolean offer() - هڪ نئون عنصر قطار ۾ داخل ڪري ٿو جيڪڏهن اهو ممڪن آهي
• Boolean add(E e) - هڪ نئون عنصر قطار ۾ داخل ڪري ٿو جيڪڏهن اهو ممڪن آهي. ڪاميابي جي صورت ۾ صحيح موٽائي ٿو ۽ هڪ غير قانوني اسٽيٽ ايڪسيپشن اڇلائي ٿو جيڪڏهن ڪا جاءِ ناهي.
• اعتراض پول () - حاصل ڪري ٿو ۽ هڪ عنصر کي هٽائي ٿو جي سر مان. واپسي null جيڪڏھن قطار خالي آھي.
• اعتراض هٽايو () - ٻيهر حاصل ڪري ٿو ۽ قطار جي سر مان هڪ عنصر کي هٽائي ٿو.
• Object peek() - ٻيهر حاصل ڪري ٿو، پر قطار جي سر مان هڪ عنصر کي نه هٽائي ٿو. واپسي null جيڪڏھن قطار خالي آھي.
• اعتراض عنصر () - ٻيهر حاصل ڪري ٿو، پر قطار جي سر مان هڪ عنصر کي ختم نٿو ڪري.

جاوا قطار جا سب انٽرفيس

قطار انٽرفيس 4 سب انٽرفيس پاران ورثي ۾ ملي ٿو - BlockingDeque<E>, BlockingQueue<E>, Deque<E>, TransferQueue<E> . توھان انھن کي 3 گروپن ۾ ورهائي سگھو ٿا: Deques، Blocking Quues ۽ Transfer Quues BlockingDeque سان جيڪي پهريان ٻنھي سان تعلق رکن ٿا. اچو ته انهن گروپن تي هڪ نظر وٺو.

ڊيڪس

Deque جو مطلب آهي D ouble- Ended Q ueue ۽ ڊيٽا جي ڪنهن به دم مان اضافو يا هٽائڻ جي حمايت ڪري ٿو قطار جي طور تي (first-in-first-out/FIFO) يا هيڊ کان هڪ ٻيو مشهور ڊيٽا ڍانچي طور اسٽيڪ ( آخري - ان- فرسٽ آئوٽ/LIFO). ڪلاس جيڪي لاڳو ٿين ٿا Deque انٽرفيس: ArrayDeque، ConcurrentLinkedDeque، LinkedBlockingDeque، LinkedList.

قطارن کي بلاڪ ڪرڻ

بلاڪ ڪرڻ واري قطار ھڪڙي قطار آھي جيڪا ھڪڙي سلسلي کي ٻن صورتن ۾ بلاڪ ڪري ٿي:

• thread هڪ خالي قطار مان عناصر حاصل ڪرڻ جي ڪوشش ڪري رهيو آهي
• thread عنصرن کي پوري قطار ۾ رکڻ جي ڪوشش ڪري رھيو آھي

جڏهن هڪ ڌاڳو هڪ خالي قطار مان شيون حاصل ڪرڻ جي ڪوشش ڪري ٿو، اهو انتظار ڪري ٿو جيستائين ڪجهه ٻيو ڌاڳو شيون قطار ۾ رکي. اهڙي طرح، جڏهن هڪ ڌاڳو عناصرن کي مڪمل قطار ۾ رکڻ جي ڪوشش ڪندو آهي، اهو انتظار ڪندو آهي جيستائين ڪجهه ٻيو ٿريڊ عناصر کي قطار مان ڪڍي عناصر لاءِ خالي جاءِ حاصل ڪرڻ لاءِ. يقينا، "مڪمل قطار" جي تصور جو مطلب آهي ته قطار هڪ محدود سائيز آهي، جيڪا عام طور تي تعمير ڪندڙ ۾ بيان ڪئي وئي آهي. معياري بلاڪنگ قطارن ۾ LinkedBlockingQueue، SynchronousQueue، ۽ ArrayBlockingQueue شامل آهن. BlockingQueue انٽرفيس جا ڪلاس لاڳو ڪرڻ : ArrayBlockingQueue، DelayQueue، LinkedBlockingDeque، LinkedBlockingQueue، LinkedTransferQueue، PriorityBlockingQueue، SynchronousQueue. BlockingDeque BlockingQueue لاءِ هڪ ذيلي انٽرفيس آهي. BlockingDeque جهڙوڪ BlockingQueue هڪ بلاڪنگ قطار آهي، پر ٻه طرفي. تنهنڪري اهو ڊيڪ انٽرفيس جي ملڪيتن کي ورثي ۾ ملي ٿو. اهو ڪيترن ئي موضوعن تي عملدرآمد تي مبني آهي، صفر عناصر جي اجازت نه ڏيندو آهي ۽ گنجائش محدود ٿي سگهي ٿي. BlockingDeque انٽرفيس جي عملن کي بلاڪ ڪري ٿو عناصر حاصل ڪرڻ جي عمل کي جيڪڏھن قطار خالي آھي، ۽ ھڪڙي عنصر کي قطار ۾ شامل ڪرڻ جيڪڏھن اھو پورو آھي.

منتقلي قطارون

TransferQueue انٽرفيس وڌائي ٿو BlockingQueue انٽرفيس. جڏهن ته BlockingQueue انٽرفيس قطارن تي عمل ڪرڻ جي برعڪس، جتي ٿريڊز کي بلاڪ ڪري سگهجي ٿو جيڪڏهن قطار خالي آهي (پڙهڻ)، يا جيڪڏهن قطار پوري آهي (لکڻ)، TransferQueue انٽرفيس قطارون لکڻ واري اسٽريم کي بلاڪ ڪنديون آهن جيستائين ٻيو وهڪرو عنصر کي حاصل نه ڪري. هن لاء هڪ منتقلي جو طريقو استعمال ڪريو. ٻين لفظن ۾، BlockingQueue جو نفاذ ضمانت ڏئي ٿو ته پروڊيوسر پاران تيار ڪيل عنصر قطار ۾ هجڻ ضروري آهي، جڏهن ته TransferQueue جو نفاذ ضمانت ڏئي ٿو ته پروڊيوسر عنصر صارف پاران "وصول" ڪيو ويو آهي. TransferQueue انٽرفيس - LinkedTransferQueue جو صرف هڪ سرڪاري جاوا عمل درآمد آهي.

جاوا قطار لاڳو ڪرڻ

اتي ڪيترائي طبقا آھن جيڪي قطار انٽرفيس کي لاڳو ڪن ٿا:

• AbstractQueue Queue Java 8 docs جي مطابق، هي خلاصو ڪلاس ڪجهه قطار جي عملن جا بنيادي عمل مهيا ڪري ٿو. اهو null عناصر جي اجازت نٿو ڏئي. هتي 3 وڌيڪ طريقا آهن شامل ڪرڻ، ختم ڪرڻ، ۽ عنصر جي بنياد تي قطار کلاسيڪل پيشڪش ، پول ، ۽ peek ، ترتيب سان. تنهن هوندي به اهي غلط يا نال واپسي ذريعي ناڪامي جي نشاندهي ڪرڻ بدران استثنا ڏين ٿا.
• ArrayBlockingQueue - هڪ مقرر ٿيل سائيز FIFO بلاڪنگ قطار هڪ صف جي مدد سان
• ArrayDeque - ڊيڪ انٽرفيس جي ريزائيبل ايري تي عمل درآمد
• ConcurrentLinkedDeque - ڳنڍيل نوڊس جي بنياد تي اڻڄاتل سمورو ڊيڪ.
• ConcurrentLinkedQueue - ڳنڍيل نوڊس جي بنياد تي اڻڄاتل سلسلي-محفوظ قطار.
• DelayQueue - هڪ وقت تي ٻڌل شيڊولنگ قطار جو پٺڀرائي هيپ
• LinkedBlockingDeque - ڊيڪ انٽرفيس جو سمورو عمل.
• LinkedBlockingQueue - هڪ اختياري طور تي پابند ٿيل FIFO بلاڪنگ قطار ڳنڍيل نوڊس جي مدد سان
• LinkedList - ٻيڻو ڳنڍيل لسٽ لسٽ ۽ ڊيڪ انٽرفيس جي عمل درآمد. سڀني اختياري لسٽ جي عملن کي لاڳو ڪري ٿو، ۽ سڀني عناصر کي اجازت ڏئي ٿو (بشمول نال)
• LinkedTransferQueue - ڳنڍيل نوڊس تي ٻڌل هڪ بيحد منتقلي قطار
• PriorityBlockingQueue - هڪ بيحد بلاڪ ڪرڻ واري ترجيحي قطار جو پٺڀرائي هيپ
• PriorityQueue - هڪ ترجيحي قطار، هيپ ڊيٽا جي جوڙجڪ جي بنياد تي
• SynchronousQueue - هڪ بلاڪ ڪرڻ واري قطار جتي هر داخل ٿيڻ واري آپريشن کي لازمي طور تي هڪ ٻئي سلسلي سان لاڳاپيل هٽائڻ واري آپريشن جو انتظار ڪرڻو پوندو، ۽ ان جي برعڪس.

سڀ کان وڌيڪ مشهور عمل آهن LinkedList، ArrayBlockingQueue ۽ PriorityQueue. اچو ته انهن کي ڏسو ۽ بهتر سمجهڻ لاءِ ڪجهه مثال ڏيون.

LinkedList

جاوا ۾ ڪلاس LinkedList لسٽ ۽ ڊيڪ انٽرفيس کي لاڳو ڪري ٿو. تنهن ڪري، اهو فهرست ۽ ڊيڪ جو هڪ ميلاپ آهي، هڪ ٻه طرفي قطار، جيڪو ٻنهي طرفن کان عناصر کي شامل ڪرڻ ۽ ختم ڪرڻ جي حمايت ڪري ٿو. جاوا ۾ LinkedList ٻه ڀيرا ڳنڍيل لسٽ آهي: لسٽ جو هر عنصر نوڊ کي سڏيندو آهي ۽ هڪ اعتراض تي مشتمل آهي ۽ ٻه پاڙيسري شين جا حوالا آهن - پويون ۽ ايندڙ. توهان شايد اهو چئي سگهون ٿا ته LinkedList ميموري استعمال ڪرڻ جي لحاظ کان تمام مؤثر نه آهي. اھو سچ آھي، پر ھي ڊيٽا جو ڍانچو ڪارائتو ٿي سگھي ٿو داخل ڪرڻ ۽ ختم ڪرڻ واري عمل جي ڪارڪردگيءَ جي صورت ۾. بهرحال اهو صرف تڏهن ٿئي ٿو جڏهن توهان انهن لاءِ ٻيهر استعمال ڪندا آهيو (هن صورت ۾ اهو مسلسل وقت ۾ ٿئي ٿو). انڊيڪس ذريعي رسائي جي عملن کي انجام ڏنو ويندو آهي ڳولا جي شروعات کان پڇاڙيءَ تائين (جيڪو به ويجهو هجي) گهربل عنصر تائين. بهرحال، عناصر جي وچ ۾ حوالن کي محفوظ ڪرڻ لاء اضافي خرچن جي باري ۾ نه وساريو. تنهن ڪري، LinkedList جاوا ۾ سڀ کان وڌيڪ مقبول قطار عمل درآمد آهي. اهو پڻ لسٽ ۽ ڊيڪ جو هڪ عمل آهي ۽ اهو اسان کي اجازت ڏئي ٿو ته هڪ ٻه طرفي قطار ٺاهي جنهن ۾ ڪنهن به شئي شامل هجي null. LinkedList عناصر جو هڪ مجموعو آهي.

LinkedList Constructors

LinkedList() بغير پيراميٽر جي استعمال ڪيو ويندو آھي خالي لسٽ ٺاھڻ لاءِ. LinkedList(Collection<? extensions E>c) ھڪڙي فهرست ٺاھڻ لاءِ آھي جنھن ۾ مخصوص ڪيل مجموعن جا عنصر شامل آھن، ترتيب ۾، اھي مجموعن جي ورجائيندڙ طرفان واپس ڪيا ويندا آھن.

مکيه LinkedList طريقا:

• add(E element) هن لسٽ جي آخر ۾ مخصوص عنصر شامل ڪريو؛
• add(int index, E element) عنصر داخل ڪري ٿو مخصوص پوزيشن انڊيڪس تي؛
• get(int index) هن لسٽ ۾ مخصوص پوزيشن تي عنصر کي واپس ڪري ٿو؛
• هٽايو (int index) عنصر کي هٽائي ٿو جيڪو پوزيشن انڊيڪس تي آهي؛
• هٽايو (Object o) هن فهرست مان o عنصر جي پهرين واقعن کي هٽائي ٿو جيڪڏهن اهو موجود آهي.
• هٽائي ٿو () لسٽ جي پهرين عنصر کي ٻيهر حاصل ڪري ٿو ۽ هٽائي ٿو.
• addFirst()، addLast() فهرست جي شروعات/آخر ۾ هڪ عنصر شامل ڪريو
• صاف () فهرست مان سڀني عناصر کي هٽائي ٿو
• contains(Object o) صحيح موٽائي ٿو جيڪڏھن لسٽ ۾ o عنصر شامل آھي.
• indexOf (Object o) o عنصر جي پهرين واقعن جي انڊيڪس کي واپس ڪري ٿو، يا -1 جيڪڏهن اهو فهرست ۾ نه آهي.
• سيٽ (int index، E عنصر) عنصر کي انڊيڪس پوزيشن تي عنصر سان تبديل ڪري ٿو
• سائيز () فهرست ۾ عناصر جي مقدار کي واپس ڪري ٿو.
• toArray() ھڪڙي صف کي واپس ڏئي ٿو جنھن ۾ سڀني لسٽ جي عناصر شامل آھن پھرين کان آخري عنصر تائين.
• پاپ () جيڪو اسٽيڪ مان هڪ عنصر کي پاپ ڪري ٿو (فهرست جي نمائندگي ڪئي وئي آهي)
• push (E e) جيڪو هڪ عنصر کي اسٽيڪ تي دٻائي ٿو (هن لسٽ جي نمائندگي ڪئي وئي آهي)

جاوا قطار مثال - LinkedList (عناصر کي مختلف طريقن سان رکڻ ۽ ختم ڪرڻ)

import java.util.*;

public class LinkedListTest {

       public static void main(String args[]){

           LinkedList<Integer> myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           //put one element into the head, not to the tail:
           myLinkedList.push(5);
           System.out.println("The new element last in will be the first: " + myLinkedList);
           //add new element at the specified position:
           myLinkedList.add(4,3);
           //put one element into the head, not to the tail (same as push):
           myLinkedList.addFirst(6);
           System.out.println(myLinkedList);
           //now remove element no 2 (it is 1):
           myLinkedList.remove(2);
           System.out.println(myLinkedList);
           //now remove the head of the list
           myLinkedList.pop();
           System.out.println(myLinkedList);
           //remove with the other method
           myLinkedList.remove();
           System.out.println(myLinkedList);
           //and with one more
           myLinkedList.poll();
           System.out.println(myLinkedList);
       }
       }

ترجيحي قطار

FIFO عام معنيٰ ۾ PriorityQueue بلڪل قطار نه آھي. ترجيحي قطار جا عنصر انھن جي قدرتي ترتيب جي مطابق ترتيب ڏنل آھن، يا قطار جي تعمير وقت تي مهيا ڪيل ھڪڙي مقابلي ڪندڙ طرفان، ان تي منحصر آھي جنھن ٺاھيندڙ استعمال ڪيو ويو آھي. بهرحال اهو اهڙو آرڊر ناهي جيئن اهو لڪير جي جوڙجڪ ۾ هجي جهڙوڪ فهرست (وڏي کان ننڍي يا ان جي برعڪس). هڪ ترجيحي قطار ترجيحي منٽ جي ڍير جي بنياد تي. هيپ هڪ ڊيٽا جي جوڙجڪ آهي جيڪا بائنري وڻ تي ٻڌل آهي . هر والدين جي ترجيح ان جي ٻارن جي ترجيحن کان وڌيڪ آهي. هڪ وڻ کي مڪمل بائنري سڏيو ويندو آهي جيڪڏهن هر والدين کي ٻن کان وڌيڪ ٻار نه آهن، ۽ سطحن جي ڀرڻ مٿي کان هيٺ تائين (ساڳئي سطح کان - کاٻي کان ساڄي تائين). بائنري هيپ پاڻ کي ٻيهر منظم ڪري ٿو هر وقت جڏهن ڪو نئون عنصر شامل ڪيو ويندو آهي يا ان مان هٽايو ويندو آهي. منٽ-هيپ جي صورت ۾، ننڍڙو عنصر ان جي داخل ٿيڻ جي ترتيب جي بغير روٽ ڏانهن وڃي ٿو. ترجيحي قطار ھن منٽ-ھيپ تي ٻڌل آھي، تنھنڪري جيڪڏھن اسان وٽ ھڪڙي ترجيحي قطار آھي عددن جي، ان جو پھريون عنصر انھن نمبرن مان ننڍو ھوندو. جيڪڏھن توھان روٽ کي ختم ڪريو، ايندڙ ننڍڙو ھڪڙو روٽ بڻجي ويندو.

مکيه ترجيحي قطار جا طريقا:

• boolean add(object) مخصوص عنصر کي ترجيحي قطار ۾ داخل ڪري ٿو. ڪاميابي جي صورت ۾ صحيح موٽائي ٿو. جيڪڏهن قطار مڪمل آهي، طريقو هڪ استثنا اڇلائي ٿو.
• boolean offer(object) هن ترجيحي قطار ۾ مخصوص عنصر داخل ڪري ٿو. جيڪڏهن قطار ڀريل آهي، طريقو غلط آهي.
• boolean remove(object) هن قطار مان مخصوص عنصر جو هڪ مثال هٽائي ٿو، جيڪڏهن اهو موجود آهي.
• اعتراض پول () هن قطار جي سر کي ٻيهر حاصل ڪري ٿو ۽ هٽائي ٿو. واپسي null جيڪڏھن قطار خالي آھي.
• void clear() ترجيحي قطار مان سڀني عناصر کي ختم ڪري ٿو.
• اعتراض عنصر () هن قطار جي سر کي هٽائڻ کان سواء حاصل ڪري ٿو. اڇلائي ٿو NoSuchElementException جيڪڏھن قطار خالي آھي.
• Object peek() ان کي هٽائڻ کان سواءِ قطار جي سر کي ٻيهر حاصل ڪري ٿو. واپسي null جيڪڏھن قطار خالي آھي.
• boolean contains(Object o) صحيح موٽائي ٿو جيڪڏهن قطار ۾ o عنصر شامل آهي.
• int size() هن قطار ۾ عناصر جو تعداد واپس ڏئي ٿو.

PriorityQueue جو مثال

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
   public static void main(String[] args) {

       Queue<Integer> queueL = new LinkedList<>();
       for (int i = 5; i > 0; i--) {
           queueL.add(i);
       }
       System.out.println("Print our LinkedList Queue (FIFO): " + queueL);
       Queue<Integer> priorityQueue = new PriorityQueue<>();

       for (int i = 5; i > 0; i--) {
       priorityQueue.offer(i);
       }

       System.out.println("PriorityQueue printing (by iterating, no elements removing): " + priorityQueue);
       System.out.println("Print PriorityQueue using poll() (by retrieval): " );
       while (!priorityQueue.isEmpty()) {
           System.out.println(priorityQueue.poll());
       }
}
}
Print our LinkedList Queue (FIFO): [5, 4, 3, 2, 1]
PriorityQueue printing (by iterating, no elements removing): [1, 2, 4, 5, 3]
Print our  PriorityQueue using poll() (by retrieval):
1
2
3
4
5

اهو سمجهڻ ضروري آهي ته ترجيحي قطارون بائنري هيپس تي ٻڌل هونديون آهن، تنهن ڪري اهي عناصر کي لڪير ۾ ترتيب ڏنل ترتيب ۾ نه رکندا آهن. جڙ کان پني تائين هر طريقو حڪم ڏنو ويو آهي، پر جڙ کان مختلف طريقا نه آهن. ان جو مطلب اهو آهي ته توهان تمام جلدي قطار جي گهٽ ۾ گهٽ عنصر حاصل ڪري سگهو ٿا. جيڪڏهن توهان هر دفعي سر کي حذف ڪريو ٿا، توهان هڪ ترتيب واري جوڙجڪ کي پرنٽ ڪندا.

ArrayBlockingQueue

ArrayBlockingQueue جي اندروني ڊيٽا جي جوڙجڪ عناصر کي ذخيرو ڪرڻ لاء هڪ سرکلر صف تي ٻڌل آهي. اها هڪ عام قطار آهي (FIFO) صورت ۾ نئين عناصر قطار جي دم تي داخل ڪيا ويا آهن، ۽ ڪڍڻ واري عملن کي قطار جي سر مان هڪ عنصر واپس آڻيندو آهي. هڪ ڀيرو ٺهيل قطار جي گنجائش تبديل نه ٿي سگهي. هڪ عنصر کي مڪمل قطار ۾ داخل ڪرڻ جي ڪوشش (وڇائي) وهڪري کي بلاڪ ڪرڻ جي اڳواڻي؛ هڪ خالي قطار مان هڪ عنصر وٺڻ جي ڪوشش پڻ موضوع کي بلاڪ ڪري ٿو. جيئن اسان اڳ ۾ چيو آهي، هي صف گول آهي. ان جو مطلب اهو آهي ته صف جي پهرين ۽ آخري عناصر کي منطقي طور تي ڀرسان علاج ڪيو وڃي ٿو. قطار اڳتي وڌندي آهي سر ۽ دم جي عنصرن جي اشارن کي هر وقت جڏهن توهان عنصر کي قطار ۾ وجهي يا ان کي قطار مان هٽايو. جيڪڏهن ڪجهه انڊيڪس صف جي آخري عنصر کي اڳتي وڌائي ٿو، اهو 0 کان ٻيهر شروع ٿئي ٿو. ان ڪري، قطار کي سڀني عنصرن کي منتقل ڪرڻ جي ضرورت ناهي ته هيڊ هٽائڻ جي صورت ۾ (جهڙوڪ عام صف ۾). بهرحال، وچ مان هڪ عنصر کي هٽائڻ جي صورت ۾ (Iterator.remove استعمال ڪندي)، عناصر کي منتقل ڪيو ويو آهي. ArrayBlockingQueue هڪ اضافي منصفانه پاليسي کي سپورٽ ڪري ٿو منصفانه پيٽرولر سان گڏ ٺاهيندڙن جي انتظار جي وهڪري جي ڪم کي ترتيب ڏيڻ لاءِ پروڊڪٽرن (عناصر داخل ڪرڻ) ۽ صارفين (عناصر ڪڍڻ). ڊفالٽ طور، آرڊر جي ضمانت نه آهي. بهرحال جيڪڏهن قطار ٺاهي وئي آهي "منصفانه == سچ" ​​سان، ArrayBlockingQueue ڪلاس جو نفاذ FIFO آرڊر ۾ سلسلي جي رسائي فراهم ڪري ٿو. برابري عام طور تي بينڊوڊٿ کي گھٽائي ٿي، پر ان سان گڏوگڏ گھٽتائي به گھٽائي ٿي ۽ وسيلن مان نڪرڻ کان روڪي ٿي.

ArrayBlockingQueue Class constructors

• ArrayBlockingQueue (int ظرفيت) مقرر ڪيل گنجائش جي قطار ٺاهي ٿي ۽ ڊفالٽ رسائي پاليسي سان.
• ArrayBlockingQueue (int ظرفيت، boolean fair) هڪ قطار ٺاهي ٿي هڪ مقرر گنجائش ۽ هڪ مخصوص رسائي واري پاليسي سان.
• ArrayBlockingQueue (int ظرفيت، boolean fair، Collection <? extensions E> c) هڪ قطار ٺاهي ٿي جيڪا مقرر ڪيل گنجائش جي رسائي واري پاليسي سان بيان ڪئي وئي آهي ۽ قطار ۾ عناصر شامل آهن.

هتي اسان کي BlockingQueueExample مثال مليو آهي. اسان ArrayBlockingQueue جي هڪ قطار ٺاهيندا آهيون هڪ عنصر جي گنجائش ۽ هڪ منصفانه پرچم سان. ٻه سٽون شروع ٿيون. انھن مان پھريون، پروڊيوسر ٿريڊ، پوسٽ ميٿڊ استعمال ڪندي پيغامن جي صف مان پيغامن کي قطار ڪري ٿو. ٻيو، صارف، ٿريڊ عناصر کي قطار مان پڙھي ٿو وٺي طريقو استعمال ڪندي ۽ انھن کي ڪنسول ۾ ڏيکاري ٿو. عناصر جو حڪم قطار لاء قدرتي ھڪڙو آھي.

import java.util.concurrent.*;

public class ArrayBlockingQueueExample {

   private BlockingQueue<Integer> blockingQueue;
   private final Integer[]  myArray = {1,2,3,4,5};

       public ArrayBlockingQueueExample ()
       { blockingQueue = new ArrayBlockingQueue<Integer>(1, true);
           (new Thread(new Producer())).start();
           (new Thread(new Consumer())).start();
       }

       class Producer implements Runnable
       {
           public void run() {
               try {
                   int counter = 0;
                   for (int i=0; i < myArray.length; i++) {
                       blockingQueue.put(myArray[i]);
                       if (counter++ < 2)
                           Thread.sleep(3000);
                   } blockingQueue.put(-1);
               }
               catch (InterruptedException e) {
                   System.err.println(e.getMessage());
               }
           }
       }

       class Consumer implements Runnable
       {
           public void run() {
               try {
                   Integer message = 0;
                   while (!((message = blockingQueue.take()).equals(-1)))
                       System.out.println(message);
               } catch (InterruptedException e) {
                   System.err.println(e.getMessage());
               }
           }
       }

       public static void main(String[] args) {
           new ArrayBlockingQueueExample();
       }
   }

پيداوار قدرتي ترتيب ۾ قطار آهي؛ پهرين ٻه عنصر دير سان ظاهر ٿيندا آهن. جيڪو توهان سکيو ان کي مضبوط ڪرڻ لاءِ، اسان توهان کي اسان جي جاوا ڪورس مان هڪ وڊيو سبق ڏسڻ جي صلاح ڏيون ٿا

قطار قطار جي آخر ۾ عناصر داخل ڪرڻ لاء استعمال ڪيو ويندو آھي ۽ قطار جي شروعات کان ھٽايو ويندو آھي. اهو FIFO تصور جي پيروي ڪري ٿو.

جاوا قطار ڪليڪشن فريم ورڪ جو حصو آھي ۽ ڪليڪشن انٽرفيس لاڳو ڪري ٿي. تنهن ڪري اهو ڪليڪشن انٽرفيس جي سڀني طريقن کي سپورٽ ڪري ٿو جهڙوڪ داخل ڪرڻ، حذف ڪرڻ وغيره.

قطار جا سڀ کان وڌيڪ استعمال ٿيل عمل آهن LinkedList، ArrayBlockingQueue ۽ PriorityQueue.

ترجيحي قطار جا عنصر انھن جي قدرتي ترتيب جي مطابق ترتيب ڏنل آھن، يا قطار جي تعمير وقت تي مهيا ڪيل ھڪڙي مقابلي ڪندڙ طرفان، ان تي منحصر آھي جنھن ٺاھيندڙ استعمال ڪيو ويو آھي.

جيڪڏهن BlockingQueues تي ڪو به نيل آپريشن ڪيو ويندو آهي، NullPointerException اڇلايو ويندو آهي.