रांग

बहुतेक लोकांसाठी, "रांग" हा शब्द फारच कमी आनंददायी सहवास लक्षात आणतो. पण आज आपण वेगवेगळ्या रांगांबद्दल बोलत आहोत — Java quees. जावामध्ये, रांग म्हणजे रांग इंटरफेसचा वारसा घेणारी कोणतीही गोष्ट, जी कलेक्शन इंटरफेसचा विस्तार करते . याचा अर्थ असा की रांगांना संग्रहासारखे मानले जाऊ शकते.

Java मधील रांगा दोन ऑपरेटिंग तत्त्वांचे समर्थन करतात: FIFO आणि LIFO .

FIFO (फर्स्ट इन, फर्स्ट आउट) तत्त्व नियमित रांगेवर नियंत्रण ठेवते — रांगेत जोडलेला पहिला घटक तो सोडणारा पहिला आहे .

LIFO (लास्ट इन, फर्स्ट आउट) तत्त्व स्टॅकच्या वर्तनाचे वर्णन करते — रांगेत जोडलेला शेवटचा घटक तो सोडणारा पहिला आहे . उदाहरणार्थ, तुम्ही कार्ड्सच्या डेकसह अशा प्रकारे कार्य कराल: तुम्ही डेकच्या तळाशी पोहोचेपर्यंत तुम्ही एका वेळी वरच्या एकावरून कार्ड काढून टाकता.

Java मधील रांग पदानुक्रम असे दिसते:

येथे तुम्ही पाहू शकता की रांगेत 3 अंमलबजावणी वर्ग आहेत: LinkedList , ArrayDeque आणि PriorityQueue . LinkedList आणि ArrayDeque थेट वारसा मिळवतात रांगेत नाही तर Deque .

Deque हा एक इंटरफेस आहे जो Java 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);
    

हा कोड चालवताना, आम्हाला मिळते:

pop() आणि poll() मधील फरक हा आहे की pop() यादी रिकामी असल्यास NoSuchElementException टाकेल , परंतु poll() null परत करेल .

आता आपण pollFirst() आणि pollLast() पद्धतींचा विचार करू.

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);
    

दोन्ही पद्धती रांगेतील पहिला/शेवटचा घटक परत करतात आणि त्यांना काढत नाहीत. रांग रिकामी असल्यास, null परत केला जाईल.

शाब्बास! आज आपण Java मध्ये रांगेत कसे काम करायचे ते शिकलो. आता तुम्हाला ते सराव मध्ये कसे वापरायचे ते माहित आहे.