Java Language
क्यु और देवता

प्रायोरिटी का उपयोग

PriorityQueue डेटा एक संरचना है। SortedSet तरह, PriorityQueue SortedSet भी अपनी प्राथमिकताओं के आधार पर अपने तत्वों को SortedSet । प्राथमिक प्राथमिकता वाले तत्व पहले आते हैं। PriorityQueue प्रकार को comparable या comparator इंटरफ़ेस को लागू करना चाहिए, जिसकी विधियां डेटा संरचना के तत्वों की प्राथमिकताओं को तय करती हैं।

//The type of the PriorityQueue is Integer.
PriorityQueue<Integer> queue = new PriorityQueue<Integer>();

//The elements are added to the PriorityQueue
queue.addAll( Arrays.asList( 9, 2, 3, 1, 3, 8 ) );

//The PriorityQueue sorts the elements by using compareTo method of the Integer Class
//The head of this queue is the least element with respect to the specified ordering
System.out.println( queue );  //The Output: [1, 2, 3, 9, 3, 8]
queue.remove();
System.out.println( queue );  //The Output: [2, 3, 3, 9, 8]
queue.remove();
System.out.println( queue );  //The Output: [3, 8, 3, 9]
queue.remove();
System.out.println( queue );  //The Output: [3, 8, 9]
queue.remove();
System.out.println( queue );  //The Output: [8, 9]
queue.remove();
System.out.println( queue );  //The Output: [9]
queue.remove();
System.out.println( queue );  //The Output: []

लिंफोलिस्ट एक फीफो कतार के रूप में

java.util.LinkedList वर्ग, java.util.List को लागू करते हुए। java.util.LinkedList java.util.Queue इंटरफ़ेस का एक सामान्य उद्देश्य कार्यान्वयन है, जो एक FIFO (फर्स्ट इन, फर्स्ट आउट) सिद्धांत पर काम कर रहा है।

नीचे, साथ उदाहरण में offer() विधि, तत्वों में डाला जाता है LinkedList । इस सम्मिलन ऑपरेशन को enqueue कहा जाता है। में while नीचे पाश, तत्वों से निकाल दिए जाते Queue फीफो पर आधारित है। इस ऑपरेशन को dequeue कहा जाता है।

Queue<String> queue = new LinkedList<String>();

queue.offer( "first element" );
queue.offer( "second element" );
queue.offer( "third element" );
queue.offer( "fourth. element" );
queue.offer( "fifth. element" );

while ( !queue.isEmpty() ) {
  System.out.println( queue.poll() );
}

इस कोड का आउटपुट है

first element
second element
third element
fourth element
fifth element

जैसा कि आउटपुट में देखा जाता है, पहले डाला गया तत्व "पहला तत्व" सबसे पहले हटा दिया जाता है, दूसरे स्थान पर "दूसरा तत्व" हटा दिया जाता है आदि।

ढेर

स्टैक क्या है?

जावा में, स्टैक वस्तुओं के लिए एक LIFO (लास्ट इन, फर्स्ट आउट) डेटा संरचना है।

स्टैक एपीआई

जावा में निम्नलिखित विधियों के साथ एक स्टैक एपीआई है

Stack()            //Creates an empty Stack
isEmpty()          //Is the Stack Empty?             Return Type: Boolean
push(Item item)    //push an item onto the stack
pop()              //removes item from top of stack  Return Type: Item
size()             //returns # of items in stack     Return Type: Int

उदाहरण

import java.util.*;

public class StackExample {

   public static void main(String args[]) {
      Stack st = new Stack();
      System.out.println("stack: " + st);
      
      st.push(10);
      System.out.println("10 was pushed to the stack");
      System.out.println("stack: " + st);
      
      st.push(15);
      System.out.println("15 was pushed to the stack");
      System.out.println("stack: " + st);
      
      st.push(80);
      System.out.println("80 was pushed to the stack");
      System.out.println("stack: " + st);
      
      st.pop();
      System.out.println("80 was popped from the stack");
      System.out.println("stack: " + st);
      
      st.pop();
      System.out.println("15 was popped from the stack");
      System.out.println("stack: " + st);
      
      st.pop();
      System.out.println("10 was popped from the stack");
      System.out.println("stack: " + st);
      
     if(st.isEmpty())
      {
         System.out.println("empty stack");
      }
   }
}

यह रिटर्न:

stack: []
10 was pushed to the stack
stack: [10]
15 was pushed to the stack
stack: [10, 15]
80 was pushed to the stack
stack: [10, 15, 80]
80 was popped from the stack
stack: [10, 15]
15 was popped from the stack
stack: [10]
10 was popped from the stack
stack: []
empty stack

BlockingQueue

एक BlockingQueue एक इंटरफ़ेस है, जो एक कतार है जो तब ब्लॉक होती है जब आप इससे बाहर निकलने की कोशिश करते हैं और कतार खाली होती है, या यदि आप इसके लिए आइटम संलग्न करने का प्रयास करते हैं और कतार पहले से ही भरी हुई है। एक खाली कतार से बाहर निकलने की कोशिश करने वाला एक धागा तब तक अवरुद्ध होता है जब तक कि कोई अन्य धागा कतार में किसी वस्तु को सम्मिलित नहीं कर देता। एक आइटम को पूर्ण कतार में रखने की कोशिश करने वाला एक धागा अवरुद्ध हो जाता है जब तक कि कोई अन्य धागा कतार में जगह नहीं बनाता है, या तो एक या एक से अधिक वस्तुओं को हटाकर या पूरी तरह से कतार को साफ करके।

ब्लॉकिंग क्यू विधियां चार रूपों में आती हैं, संचालन के विभिन्न तरीकों से जिन्हें तुरंत संतुष्ट नहीं किया जा सकता है, लेकिन भविष्य में किसी बिंदु पर संतुष्ट हो सकते हैं: एक अपवाद को फेंक देता है, दूसरा एक विशेष मान (या तो शून्य या गलत, के आधार पर देता है) ऑपरेशन), तीसरा तब तक चालू थ्रेड को अनिश्चित काल के लिए ब्लॉक कर देता है जब तक कि ऑपरेशन सफल नहीं हो सकता है, और चौथे ब्लॉक केवल एक निश्चित अधिकतम समय सीमा से पहले उठने से पहले।

एक BlockingQueue बाउंड या अनबाउंड किया जा सकता है। एक बंधे हुए ब्लॉकिंग क्यू को प्रारंभिक क्षमता के साथ जोड़ा जाता है।

BlockingQueue<String> bQueue = new ArrayBlockingQueue<String>(2);

एक पुट () विधि के लिए किसी भी कॉल को अवरुद्ध कर दिया जाएगा यदि कतार का आकार परिभाषित प्रारंभिक क्षमता के बराबर है।

एक निर्बाध कतार वह है जो क्षमता के बिना आरंभीकृत होती है, वास्तव में डिफ़ॉल्ट रूप से इसे Integer.MAX_VALUE के साथ प्रारंभ किया जाता है।

BlockingQueue कुछ सामान्य कार्यान्वयन हैं:

1. ArrayBlockingQueue
2. LinkedBlockingQueue
3. PriorityBlockingQueue

अब आइए ArrayBlockingQueue का एक उदाहरण देखें:

BlockingQueue<String> bQueue = new ArrayBlockingQueue<>(2);
bQueue.put("This is entry 1");
System.out.println("Entry one done");
bQueue.put("This is entry 2");
System.out.println("Entry two done");
bQueue.put("This is entry 3");
System.out.println("Entry three done");

यह प्रिंट करेगा:

Entry one done
Entry two done

और थ्रेड को दूसरे आउटपुट के बाद ब्लॉक किया जाएगा।

कतार इंटरफ़ेस

मूल बातें

एक Queue प्रसंस्करण से पहले तत्वों को रखने के लिए एक संग्रह है। आमतौर पर कतारें, लेकिन जरूरी नहीं, तत्वों को एफआईएफओ (पहले-पहले-पहले) तरीके से।

कतार का प्रमुख वह तत्व है जिसे हटाने या मतदान करने के लिए कॉल द्वारा हटाया जाएगा। एक FIFO कतार में, सभी नए तत्वों को कतार की पूंछ पर डाला जाता है।

कतार इंटरफ़ेस

public interface Queue<E> extends Collection<E> {
    boolean add(E e);

    boolean offer(E e);

    E remove();

    E poll();

    E element();

    E peek();
}

प्रत्येक Queue विधि दो रूपों में मौजूद है:

• यदि ऑपरेशन विफल हो जाता है तो एक अपवाद फेंकता है;
• यदि ऑपरेशन विफल रहता है (ऑपरेशन के आधार पर या तो null या false ) तो अन्य एक विशेष मूल्य देता है।

Deque

एक Deque एक "डबल एंडेड कतार" है जिसका मतलब है कि तत्वों को कतार के सामने या पूंछ में जोड़ा जा सकता है। कतार केवल एक कतार की पूंछ में तत्वों को जोड़ सकती है।

Deque को Queue इंटरफ़ेस विरासत में मिला है जिसका अर्थ है कि नियमित विधियाँ बनी हुई हैं, हालाँकि Deque इंटरफ़ेस कतार के साथ अधिक लचीले होने के लिए अतिरिक्त तरीके प्रदान करता है। अतिरिक्त तरीके वास्तव में उनके लिए स्वयं बोलते हैं यदि आप जानते हैं कि एक कतार कैसे काम करती है, क्योंकि उन तरीकों का उद्देश्य अधिक लचीलापन जोड़ना है:

बेशक offer , poll और peek लिए समान विकल्प उपलब्ध हैं, हालांकि वे अपवादों के साथ काम नहीं करते हैं, बल्कि विशेष मूल्यों के साथ। यहां वे क्या करते हैं, यह दिखाने का कोई मतलब नहीं है।

तत्वों को जोड़ना और एक्सेस करना

एक Deque की पूंछ में तत्वों को जोड़ने के लिए आप इसके add() विधि को कहते हैं। आप addFirst() और addLast() विधियों का भी उपयोग कर सकते हैं, जो कि तत्व को सिर और पूंछ की पूंछ में जोड़ते हैं।

Deque<String> dequeA = new LinkedList<>();

dequeA.add("element 1");      //add element at tail
dequeA.addFirst("element 2"); //add element at head
dequeA.addLast("element 3");  //add element at tail

आप तत्व को कतार से बाहर निकाले बिना कतार के शीर्ष पर तत्व को देख सकते हैं। यह element() विधि के माध्यम से किया जाता है। तुम भी उपयोग कर सकते हैं getFirst() और getLast() तरीकों, जिसमें प्रथम और अंतिम तत्व लौट Deque । यहाँ है कि कैसे दिखता है:

String firstElement0 = dequeA.element();
String firstElement1 = dequeA.getFirst();
String lastElement = dequeA.getLast();

तत्वों को निकालना

एक छल से तत्वों को हटाने के लिए, आप remove() , removeFirst() और removeLast() विधियों को removeLast() करते हैं। कुछ उदाहरण निम्नलिखित हैं:

String firstElement = dequeA.remove();
String firstElement = dequeA.removeFirst();
String lastElement  = dequeA.removeLast();