Queue Interface

Queue ဆိုသည်မှာ Collection တစ်မျိုးဖြစ်ပြီး၊ ပါဝင်သော Element များအတွင်းမှ မည်သည့် Element အား ဦးစားပေး အသုံးပြုမည်ဆိုသည်ကို ရွေးချယ် သတ်မှတ်နိုင်ပါသည်။ Collection တွင်ပါဝင်သော လုပ်ဆောင်မှု့များ အပြင် Queue တွင် ပါဝင်သော Element များအပေါ်၊ သွင်းခြင်း၊ ထုတ်ခြင်း နှင့် စစ်ဆေးခြင်း အစရှိသည့် လုပ်ဆောင်ချက်များကို ဖြည့်စွက်ထားပါသည်။

Queue.java

public interface Queue<E> extends Collection<E> {
    E element();
    boolean offer(E e);
    E peek();
    E poll();
    E remove();
}

Queue ၏ လုပ်ဆောင်ချက်များသည် များသောအား ဖြင့် ပုံစံ ၂ခု ပံ့ပိုးထားသည်က များ၏။

1. လုပ်ဆောင်ချက်အား လုပ်ဆောင်၍ မအောင်မြင်သော အခါ Exception အား Throw လုပ်သည့် ပုံစံ။
2.  လုပ်ဆောင်ချက်အား လုပ်ဆောင်၍ မအောင်မြင်သော အခါသတ်မှတ်ထားသော တန်ဖိုးတစ်ခုအား (null, false ဒါမှမဟုတ် တစ်ခုခု) return ပြန်လုပ်သည့် ပုံစံ

Queue Interface Structure

Type of Operation	Throws exception	Returns special value
Insert	add(e)	offer(e)
Remove	remove()	poll()
Examine	element()	peek()

Queue များသည် များသောအားဖြင့် ၎င်း၏ Element များအား FIFO (First-In-First-Out) စီနည်းကို အသုံးပြု၍ စီစဉ်ထား၏။ သို့ရာတွင် Priority Queue ကဲ့သို့ အချို့သော Queue များမှာမူ၊ Element ရဲ့ တန်ဖိုးအပေါ်မှုတည်ပြီး Order လုပ်လေ့ရှိ၏။ သို့ရာတွင် မည်သည့် Queue မဆို ၎င်းတို့၏ Element များ၏ ဦးတည်ရာသည် Queue#remove နှင့် Queue#pull အား ခေါ်ဆိုမည့် ဘက်သို့ ဦးတည်ထားကြပါသည်။ FIFO Queue တစ်ခုမှာတော့ အသစ် Insert လုပ်သည့် Element များအား Order ၏ နောက်ဆုံးတွင် ဖြည့်စွက်ပါသည်။ အခြားသော Queue များဆိုပါက ၎င်းတို့ ကိုယ်ပိုင် သတ်မှတ်ချက် နည်းလမ်းများဖြင့် နေရာချထား လေ့ရှိ၏။ ထို့ကြောင့် Queue Implementations များဟာ Ordering Properties များအပေါ်မှုတည်၍ ကန့်သန့် ရေးသားသင့် ပေသည်။

တဖန် Implementation များတွင် ပါဝင်သော Element အရေအတွက်အား ကန့်သတ်နိုင်ပါသေးသည်။ ဤကဲ့သို့ ကန့်သတ်ထားသော Queue များအား Bounded ဟု ခေါ်ဆိုလေ့ရှိ၏။ java.concurrent Package အောက်တွင် ပါဝင်သော Queue များမှာ Bounded များဖြစ်ကြပြီး၊ java.util Package အောက်ရှိ Queue Implementation များမှာ Bounded များ မဟုတ်ကြပါ။

Collection Interface မှ အမွေးဆက်ခံထားသော add လုပ်ဆောင်ကို အသုံးပြု၍ Queue ၏ အရေအတွက် ကန့်သတ်ချက် ကျော်လွန်၍ Element များအား Insert လုပ်ပါက IllegalStatteException အား Throw လုပ်မည်ဖြစ်သည်။ အကယ်၍ အဆိုပါ အနေအထားမျိုးတွင် Queue#offer အား အသုံးပြုပါက Insert လုပ်၍မရကြောင်း false အား return လုပ်ခြင်း ဖြင့် အသိပေးမည် ဖြစ်ပါသည်။

Queue#remove နှင့် poll သည်လည်း Collection အတွင်းရှင် ဦးဆုံး Element အား ဖျက်ထုတ်ပြစ်ပြီး၊ ၎င်းအား return လုပ်မည် ဖြစ်သည်။ ကွာခြားသည်မှာ Collection အတွင်း Element က မရှိတော့သော အခါ ဖြစ်သည်။ ထိုအခါမျိုးတွင် remove အား ခေါ်ဆိုပါက NoSuchElementException အား throw လုပ်မည် ဖြစ်ပြီး၊ poll အား ခေါ်ဆိုပါက null အား return လုပ်မည် ဖြစ်ပါသည်။

Queue#element နှင့် peekသည်လည်း Headနေရာတွင်ရှိသော Element အား ပြန်ပေးမည် ဖြစ်သော်လည်း ဖျက်ထုတ်ပြစ်ခြင်း မရှိပါ။ Collection အတွင်း Elementမရှိသောအခါ element သည် NoSuchElementException အား throw လုပ်မည် ဖြစ်ပြီး၊ peek အား ခေါ်ဆိုပါက null အား return လုပ်မည် ဖြစ်ပါသည်။

များသောအားဖြင့် Queue များသည် Null အား add လုပ်၍မရပေ။ သို့ရာတွင် ခြွင်းချက်အနေဖြင့် LinkedList Implementation များသည် Null အား add လုပ်၍ရပါသည်။ poll နှင့် peek များသည် null အား အဓိပ္ပါယ်တစ်မျိုး အနေဖြင့်အသုံးပြု နေပါသဖြင့် ဤထူးခြားချက်အား အသုံးမပြုသင့်ပေ။

General Purpose Implementations

• LinkedList
  LinkedList သည် Queue အင်တာဖေစ်အား Implement လုပ်ထားသော General Purpose Implementation Class တစ်မျိုးဖြစ်ပြီး၊ FIFO (First-In-First-Out) Queue Ordering အား အသုံးပြုထား၏။
• PriorityQueue
  PriorityQueue သည် Heap Data Structure ပုံစံအား အသုံးပြုထားသော Queue ရဲ့ General Purpose Implementation တစ်မျိုးဖြစ်၏။ Heap Data Structure ဆိုသည်မှာ Tree Data Structure ပုံစံရှိပြီး၊ Parent Node ဟာ Child Node ထက် တူရင်တူ၊ မတူရင်ပို၍ ကြီးရမည် ဟူသော သတ်မှတ်ချက်ရှိပါသည်။

Queue ရဲ့ သဘောသဘာဝအား တည်းခေါက်မိစေရန် Count Down လုပ်သည့် နမှုနာ ပရိုဂရမ်တစ်ခုကို ရေးကြည့်ပါမည်။ ပရိုဂရမ်မှ Argument အနေဖြင့် Count Down လုပ်မည့် ကိန်းတစ်ခုကို ရယူပြီး၊ အဲ့ဒီကိန်းမှစကာ နောက်ဆုံး သုညဖြစ်သည် အထိ FIFO Queue ထဲသို့ ထည့်သိမ်းထားပါမည်။ ပြီးပါက တစ်စက္ကန့် တစ်ခါ Queue ထဲမှ ထုတ်ပြီး ရေတွက်သွားပါမည်။

CountDown.java

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

public class CountDown {

 public static void main(String[] args) throws InterruptedException {
  if(args.length < 1)
   System.err.println("Please set the time to count!");

  Queue<Integer> que = new LinkedList<>();
  for(int i=Integer.parseInt(args[0]); i > 0; i--)
   que.offer(i);
  
  while(!que.isEmpty()) {
   System.out.println(que.poll());
   Thread.sleep(1000);
  }
 }

}

ကွန်ပိုင်းလုပ်၍ အလုပ်ခိုင်းကြည့်သော အခါ အောက်ပါအတိုင်း အလုပ်လုပ်နိုင်သည်ကို တွေ့ရပါမည်။

ဆက်ပါဦးမည်။ လေးစားစွာဖြင့်။

မင်းလွင်