క్యూ

చాలా మందికి, "క్యూ" అనే పదం చాలా తక్కువ ఆహ్లాదకరమైన అనుబంధాలను గుర్తుకు తెస్తుంది. కానీ ఈ రోజు మనం వివిధ క్యూల గురించి మాట్లాడుతున్నాము - జావా క్యూలు. జావాలో, క్యూ అనేది క్యూ ఇంటర్‌ఫేస్‌ను వారసత్వంగా పొందే ఏదైనా, ఇది కలెక్షన్ ఇంటర్‌ఫేస్‌ను విస్తరిస్తుంది . అంటే క్యూలను కలెక్షన్స్ లాగా పరిగణించవచ్చు.

జావాలోని క్యూలు రెండు ఆపరేటింగ్ సూత్రాలకు మద్దతు ఇస్తాయి: FIFO మరియు LIFO .

FIFO (ఫస్ట్ ఇన్, ఫస్ట్ అవుట్) సూత్రం సాధారణ క్యూను నియంత్రిస్తుంది - క్యూకి జోడించిన మొదటి మూలకం దానిని వదిలివేస్తుంది .

LIFO (లాస్ట్ ఇన్, ఫస్ట్ అవుట్) సూత్రం స్టాక్ యొక్క ప్రవర్తనను వివరిస్తుంది - క్యూకి జోడించిన చివరి మూలకం దానిని వదిలివేయడానికి మొదటిది . ఉదాహరణకు, మీరు డెక్ కార్డ్‌లతో ఈ విధంగా పని చేస్తారు: మీరు డెక్ దిగువకు చేరుకునే వరకు ఒక్కోసారి టాప్‌లో ఉన్న కార్డ్‌లను తీసివేస్తారు.

జావాలోని క్యూ సోపానక్రమం ఇలా కనిపిస్తుంది:

క్యూలో 3 అమలు తరగతులు ఉన్నాయని మీరు ఇక్కడ చూడవచ్చు : లింక్డ్‌లిస్ట్ , అర్రేడిక్ మరియు ప్రయారిటీ క్యూ . LinkedList మరియు ArrayDeque నేరుగా క్యూ కాకుండా వారసత్వంగా పొందుతాయి , కానీ Deque .

Deque అనేది జావా 6లో జోడించబడిన ఇంటర్‌ఫేస్. ఇది క్యూల కోసం ఉపయోగపడే అనేక పద్ధతులను కలిగి ఉంటుంది మరియు క్యూను డబుల్-ఎండ్ (లేదా ద్వి దిశాత్మక) క్యూగా పని చేయడానికి అనుమతిస్తుంది. అంటే అది FIFOమరియుLIFOకావచ్చు.

Deque ఇంటర్‌ఫేస్ యొక్క ఇద్దరు వారసులలో ఒకరు ArrayDeque . ఇది రెండు చివరల నుండి ఎలిమెంట్‌లను చొప్పించడానికి మరియు తీసివేయడానికి మిమ్మల్ని అనుమతించే డబుల్-ఎండ్ క్యూకి మద్దతు ఇస్తుంది. ఇది స్వయంచాలకంగా పరిమాణంలో పెరిగే డైనమిక్ శ్రేణి.

PriorityQueue క్లాస్ కూడా ఉంది , ఇది క్యూ యొక్క ప్రత్యక్ష వారసుడు: ఇది Dequeని అమలు చేసే తరగతుల కంటే భిన్నంగా ప్రవర్తిస్తుంది .

PriorityQueue అనేది డిఫాల్ట్‌గా వాటి సహజ క్రమానికి అనుగుణంగా మూలకాలను నిర్వహించే ప్రాధాన్యతా క్యూ. ఇక్కడ సార్టింగ్ పోల్చదగిన మరియు కంపారిటర్ ఇంటర్‌ఫేస్‌లను ఉపయోగిస్తుంది. సూత్రం TreeSet లేదా TreeMap తో సమానంగా ఉంటుంది — పోల్చదగిన ఇంటర్‌ఫేస్‌ని ఉపయోగించేమరియు వారి స్వంత క్రమాన్ని కలిగి ఉండే తరగతులు.

PriorityQueue<String> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(String::length));

priorityQueue.add("Andrew");
priorityQueue.add("John");
priorityQueue.add("Rob");

while (!priorityQueue.isEmpty()) {
   System.out.println(priorityQueue.remove());
}

మీరు ఈ ఉదాహరణను అమలు చేస్తే, మీరు కన్సోల్‌లో ఏమి చూస్తారు:

మేము సాధారణ సేకరణలతో కాకుండా క్యూలతో పని చేస్తున్నాము కాబట్టి, మేము జాబితా నుండి మూలకాలను తీసివేయాలి. దీన్ని చేయడానికి, మేము ఈ నిర్మాణాన్ని ఉపయోగిస్తాము:

while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.remove());
}

Deque ఇంటర్‌ఫేస్ క్యూ పద్ధతులను వారసత్వంగా పొందుతుంది మరియు దాని స్వంత ఆసక్తికరమైన పద్ధతులను జోడిస్తుంది :

ఆచరణలో ఉన్న ఈ పద్ధతుల్లో కొన్నింటిని ఇప్పుడు చూద్దాం.

ముందుగా, క్యూకి ఒక మూలకాన్ని జోడిద్దాం:

Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple"); // Adds "Apple" to the end of the queue
        deque.addFirst("Orange"); // Adds "Orange" to the front of the queue
        deque.addLast("Pineapple"); // Adds "Pineapple" to the end of the queue
  
        System.out.println(deque);
    

ఇప్పుడు క్యూ నుండి విలువలను పొందండి:

	Deque<String> deque = new ArrayDeque<>();

	deque.add("Apple"); 
        deque.addFirst("Orange"); 
        deque.addLast("Pineapple"); 

         
        System.out.println("The first element is: "+ deque.getFirst());
                          
        System.out.println("The last element is: " + deque.getLast());
                          
    }
    

ఈ కోడ్ క్యూలోని మొదటి మరియు చివరి మూలకాన్ని ప్రదర్శిస్తుంది.

         Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple"); 
        deque.addFirst("Orange"); 
        deque.addLast("Pineapple"); 
        deque.add("Lemon");

System.out.println(deque.pop()); // Get and remove the first element of the queue
System.out.println(deque.poll()); // Get and remove the first element of the queue

System.out.println(deque);
    

ఈ కోడ్‌ని అమలు చేయడం ద్వారా, మేము పొందుతాము:

పాప్() మరియు పోల్() మధ్య వ్యత్యాసం ఏమిటంటే, జాబితా ఖాళీగా ఉన్నట్లయితే, పాప్() NoSuchElementExceptionని విసిరివేస్తుంది , కానీ పోల్() శూన్యాన్ని అందిస్తుంది .

ఇప్పుడు మనం పోల్‌ఫస్ట్() మరియు పోల్‌లాస్ట్() పద్ధతులను పరిశీలిస్తాము .

Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple"); 
        deque.addFirst("Orange"); 
        deque.addLast("Pineapple"); 
        deque.add("Lemon");

System.out.println(deque.pollFirst()); // Get and remove the first element of the queue
System.out.println(deque.pollLast()); // Get and remove the last element of the queue.
System.out.println(deque);
    

రెండు పద్ధతులు క్యూ నుండి విలువను తిరిగి మరియు తీసివేయబడతాయి.

ఇక్కడ peekFirst() మరియు peekLast() పద్ధతులను ఉపయోగించే ఉదాహరణ :

Deque<String> friends = new ArrayDeque<>();

friends.add("John");
friends.add("Rob");
friends.add("Greg");
friends.add("Max");
friends.add("Oliver");

System.out.println("The first element is: " + friends.peekFirst());
System.out.println("The last element is: " + friends.peekLast());

System.out.println(friends);
    

రెండు పద్ధతులు క్యూ నుండి మొదటి/చివరి ఎలిమెంట్‌ను తిరిగి అందిస్తాయి మరియు వాటిని తీసివేయవద్దు. క్యూ ఖాళీగా ఉంటే, శూన్యత తిరిగి ఇవ్వబడుతుంది.

బాగా చేసారు! ఈ రోజు మనం జావాలో క్యూలతో ఎలా పని చేయాలో నేర్చుకున్నాము. వాటిని ఆచరణలో ఎలా ఉపయోగించాలో ఇప్పుడు మీకు తెలుసు.