जावा डेक इंटरफ़ेस

Java Deque एक डेटा संरचना है जो एक साधारण क्यू और स्टैक को जोड़ती है। आप Deque के हेड और टेल दोनों में तत्वों को जोड़ या हटा सकते हैं। "पारंपरिक" कतार में आप तत्वों को पंक्ति की पूंछ (अंतिम तत्व के बाद) में जोड़ते हैं और कतार के प्रमुख से तत्वों को हटाते हैं। इस सिद्धांत को फर्स्ट इन फर्स्ट आउट (FIFO) कहा जाता है और यह वास्तविक जीवन में ग्राहकों की किसी भी सामान्य पंक्ति की तरह काम करता है। जावा क्यू में एक इंटरफेस है, जो कलेक्शंस फ्रेमवर्क का एक हिस्सा है। स्टैक नामक एक महत्वपूर्ण डेटा संरचना भी है, एक सूची जो पूरी तरह से विपरीत सिद्धांत में तत्वों के साथ काम करती है, LIFO - लास्ट इन, फ़र्स्ट आउट। यह प्लेटों के ढेर के समान है, जोड़ना या हटाना केवल शीर्ष पर ही संभव है।

कतार बनाम डेक

डेक थोड़े अजीब प्रकार की कतार है: आप पूंछ और रेखा के सिर दोनों में नए तत्व जोड़ सकते हैं। हटाने के साथ वही कहानी: आप इस संरचना से अंतिम या पहला तत्व निकाल सकते हैं। इसलिए, यह स्टैक और कतार का मिश्रण प्रतीत होता है। "डेक" नाम का अर्थ है "डबल एंडेड कतार"। "डेक" का उच्चारण ताश के पत्तों के "डेक" की तरह किया जाता है और आप जानते हैं क्या? यह कुछ हद तक ताश के असली डेक के समान है: आप ऐसी गड्डी के नीचे या ऊपर से एक पत्ता ले सकते हैं। कुछ रेखीय संरचना के दोनों पक्षों से तत्वों को जोड़ना या हटाना चाहते हैं? डेक का प्रयोग करें। जावा 8 या लगभग कोई अन्य संस्करण इसका समर्थन करता है। ईंटों से बने एक विशिष्ट लेगो ईंट और एक-स्तंभ "टॉवर" की कल्पना करें। आप टावर के ऊपर या नीचे एक नई ईंट जोड़ सकते हैं। आप दोनों तरफ से एक ईंट भी निकाल सकते हैं। यहां हमारे पास एक उदाहरण है: हम सभी पीली ईंटों को ऊपर और सभी लाल ईंटों को नीचे जोड़ते हैं। हम इस उदाहरण को जल्द ही जावा कोड के साथ प्रदर्शित करेंगे। तो आप Java Deque के दोनों सिरों से कतारबद्ध और विपंक्ति कर सकते हैं, इसका मतलब है कि आप कतार और ढेर दोनों के रूप में Deque का उपयोग कर सकते हैं। जावा में स्टैक के बारे में पढ़ें: जावा स्टैक 101: स्टैक क्लास में डील जावा में क्यू के बारे में पढ़ें: जावा क्यू इंटरफेस और इसके कार्यान्वयन

डेक की विशेषताएं

• जावा में डेक एक इंटरफ़ेस है, जो कार्यान्वयन एक आकार बदलने योग्य सरणी का समर्थन प्रदान करता है। तो आपके पास प्रतिबंध-मुक्त क्षमता की एक सरणी है और आप अपनी आवश्यकताओं के अनुसार नए तत्व जोड़ सकते हैं।
• एकाधिक थ्रेड्स द्वारा समवर्ती पहुंच Deque द्वारा समर्थित नहीं है
• बाहरी तुल्यकालन के अभाव में डेक थ्रेड-सुरक्षित नहीं है।
• सरणी डेक में किसी भी अशक्त तत्वों की अनुमति नहीं है।

डेक जावा इंटरफ़ेस घोषणा

public interface Deque<E> extends Queue<E>

जावा डेक तरीके

java.util.Deque एक इंटरफ़ेस है जो जावा कतार इंटरफ़ेस को विस्तारित करता है और एक डबल एंडेड कतार का प्रतिनिधित्व करता है। तो आप डेक के साथ काम करते समय सभी जावा कतार विधियों का उपयोग कर सकते हैं। भले ही Deque स्टैक इंटरफ़ेस का विस्तार नहीं करता है, Deque इंटरफ़ेस उन विधियों को परिभाषित करता है जो आपको पुश , पीक और पॉप जैसे विशिष्ट स्टैक संचालन करने में सक्षम बनाती हैं ।

• बूलियन ऐड (तत्व) डेक की पूंछ में एक तत्व जोड़ता है। सफलता पर सत्य लौटाता है, यदि वर्तमान में कोई स्थान उपलब्ध नहीं है तो IllegalStateException फेंकता है।
• AddFirst(element) Deque के शीर्ष पर एक तत्व जोड़ता है।
• AddLast(element) Deque के टेल में एक एलिमेंट जोड़ता है।
• प्रस्ताव (तत्व) पूंछ में एक तत्व जोड़ता है और सम्मिलन सफल होने पर समझाने के लिए एक बूलियन देता है।
• ऑफ़रफर्स्ट (तत्व) सिर में एक तत्व जोड़ता है और सम्मिलन सफल होने पर व्याख्या करने के लिए एक बूलियन देता है।
• ऑफ़रलास्ट (तत्व) पूंछ में एक तत्व जोड़ता है और सम्मिलन सफल होने पर समझाने के लिए एक बूलियन देता है।
• इटरेटर () डेक के लिए एक पुनरावर्तक लौटाता है।
• अवरोही इटरेटर () एक पुनरावर्तक देता है जिसमें इस डेक के लिए रिवर्स ऑर्डर होता है।
• पुश (तत्व) सिर में एक तत्व जोड़ता है।
• पॉप (तत्व) सिर से एक तत्व निकालता है और उसे वापस करता है।
• removeFirst() तत्व को सिर पर हटा देता है।
• removeLast() तत्व को पूंछ से हटा देता है।
• पोल () इस deque (दूसरे शब्दों में, इस deque का पहला तत्व) द्वारा दर्शाए गए कतार के प्रमुख को पुनः प्राप्त करता है और हटाता है, या यदि यह deque खाली है तो अशक्त हो जाता है।
• पोलफ़र्स्ट () इस डेक के पहले तत्व को पुनः प्राप्त करता है और हटाता है, या यदि यह डेक खाली है, तो यह शून्य हो जाता है।
• पोललास्ट () इस डेक के अंतिम तत्व को पुनः प्राप्त करता है और हटाता है, या यदि यह डेक खाली है तो अशक्त हो जाता है।
• peek () इस deque (दूसरे शब्दों में, इस deque का पहला तत्व) द्वारा दर्शाए गए कतार के प्रमुख को पुनर्प्राप्त करता है, लेकिन हटाता नहीं है, या यदि यह deque खाली है, तो यह शून्य हो जाता है।
• peekFirst() इस डेक के पहले तत्व को पुनर्प्राप्त करता है, लेकिन हटाता नहीं है, या यदि यह डेक खाली है तो शून्य वापस आ जाता है।
• peekLast() इस deque के अंतिम तत्व को पुनर्प्राप्त करता है, लेकिन हटाता नहीं है, या यदि यह deque खाली है, तो यह शून्य हो जाता है।

यहाँ नीचे दी गई तालिका में सभी विधियों को समूहों द्वारा विभाजित किया गया है। जैसा कि आप देख सकते हैं कि किसी तत्व को जोड़ने और निकालने के लिए कई अलग-अलग तरीके हैं। उदाहरण के लिए, रिमूवफर्स्ट () और पॉप () दोनों पहले तत्व को डेक से हटाते हैं। स्टैक से दूसरा "आया"। इसका मतलब है कि यदि आप अपने ArrayDeque को केवल स्टैक के रूप में उपयोग करते हैं, तो निकालने के लिए पॉप () का उपयोग करें, जोड़ने के लिए पुश () और जांच करने के लिए पीक () का उपयोग करें। यह आपके कोड को अन्य डेवलपर्स के लिए अधिक समझदार बनाता है।

डेक कार्यान्वयन

Java Deque एक इंटरफ़ेस है और Java Collections API में इसका कार्यान्वयन है:

• java.util.LinkedList // सूची और डेक कार्यान्वयन
• java.util.ArrayDeque // डेक कार्यान्वयन, जावा लाइब्रेरी

लिंक्डलिस्ट क्लास एक कतार या डेक को मॉडल करने के लिए आंतरिक रूप से एक डबल-लिंक्ड सूची का उपयोग करता है। ArrayDeque वर्ग तत्वों को आंतरिक रूप से सरणी में संग्रहीत करता है। यदि तत्वों की संख्या सरणी के आयतन से अधिक हो जाती है, तो एक नई सरणी आवंटित की जाती है, और सभी तत्वों को स्थानांतरित कर दिया जाता है। इसका मतलब है कि ArrayDeque जरूरतों से बढ़ता है।

ऐरेडेक वर्ग

ArrayDeque <E> वर्ग एक सामान्य दो दिशात्मक कतार है, जो एब्सट्रैक्ट कोलेक्शन क्लास से कार्यक्षमता प्राप्त करता है और Deque इंटरफ़ेस का उपयोग करता है। ArrayDeque deque और resizable-array का उपयोग करने की सुविधा प्रदान करता है। प्रारंभ में, सरणी को आकार 16 के साथ प्रारंभ किया गया है। इसे दो-तरफ़ा कतार के रूप में लागू किया गया है, जहाँ यह दो पॉइंटर्स, अर्थात् सिर और पूंछ का समर्थन करता है। यह एब्सट्रैक्ट कोलेक्शन क्लास को इनहेरिट करता है और डेक इंटरफेस को लागू करता है। ArrayDeque क्लास के बारे में महत्वपूर्ण बिंदु हैं:

• आप ArrayDeque के टेल और हेड से तत्वों को जोड़ या हटा सकते हैं
• अशक्त तत्वों की अनुमति नहीं है
• बाहरी तुल्यकालन के अभाव में ArrayDeque थ्रेड सुरक्षित नहीं है।
• ArrayDeque में कोई क्षमता प्रतिबंध नहीं है।

ArrayDeque क्लास कंस्ट्रक्टर्स

• ArrayDeque() एक खाली कतार बनाता है।
• ArrayDeque (संग्रह <? विस्तार E> संग्रह) संग्रह संग्रह तत्वों से भरी एक कतार बनाता है।
• ArrayDeque (पूर्णांक क्षमता) प्रारंभिक क्षमता क्षमता के साथ एक कतार बनाता है । यदि आप प्रारंभिक क्षमता निर्दिष्ट नहीं करते हैं, तो डिफ़ॉल्ट क्षमता 16 है।

जावा डेक उदाहरण - ArrayDeque

लेख की शुरुआत से लेगो टॉवर का उदाहरण याद रखें? आइए लेगो ब्रिक्स से बने एक-स्तंभ वाले टावर बनाने के लिए एक क्लास बनाएं। ईंटें लाल, पीली या नीली हो सकती हैं। हमारा टावर बनाने का नियम: हम लाल ईंटों को नीचे और पीली ईंटों को ऊपर रखते हैं। बिग जावा डेक उदाहरण

//enum with colors
public enum Color {
   RED, YELLOW, BLUE;
}

//class for the standard Lego Brick. You can connect or disconnect the Brick, it has color
public class LegoBrick {
   Color color;
   boolean isConnected;

   public void connect() {
       System.out.println("This brick is connected");
       this.isConnected = true;
   }

   public void disconnect() {
       System.out.println("Disconnected");
       isConnected = false;
   }

   public LegoBrick(Color color, boolean isConnected) {
       this.color = color;
       this.isConnected = isConnected;
   }

   public Color getColor() {
       return color;
   }

   public boolean isConnected() {
       return isConnected;
   }

   @Override
   public String toString() {
       return "LegoBrick{" +
              "color=" + color +
              ", isConnected=" + isConnected +
              '}';
   }
}

यहाँ हमारा टॉवर वर्ग है। हम एक टावर शुरू करते हैं। आरंभिक टावर लाल और पीले रंग की मात्रा पर निर्भर करता है। हम टावर में ईंट जोड़ सकते हैं या उसे हटा सकते हैं। अगर यह पीला है तो हम ऊपर से ईंट जोड़ते हैं और अगर यह लाल है तो इसे नीचे से जोड़ते हैं।

import java.util.ArrayDeque;
public class LegoTower {
   ArrayDeque<LegoBrick> myTower;
   int quantityOfReds;
   int quantityOfYellows;

   public void addBrickToTower(LegoBrick newLegoBrick) {
       if (newLegoBrick.getColor() == Color.YELLOW) {
           this.myTower.offerLast(newLegoBrick);
           quantityOfYellows++;
       }
	//we can use addFirst(e)/push(e) instead of offerFirst here
       if (newLegoBrick.getColor() == Color.RED) {
           myTower.offerFirst(newLegoBrick);
           quantityOfReds++;
       }
   }

   public void removeBrickFromTower (LegoBrick legoBrick) {
       if (legoBrick.getColor() == Color.YELLOW) {
           this.myTower.removeLast();
           quantityOfYellows--;
       }
       if (legoBrick.getColor() == Color.RED) {
           myTower.removeFirst();
           quantityOfReds--;
       }
       legoBrick.isConnected = false;

   }

   public LegoTower(int quantityOfReds, int quantityOfYellows) {

       myTower = new ArrayDeque<>();
       this.quantityOfReds = quantityOfReds;
       this.quantityOfYellows = quantityOfYellows;
       for (int i = 0; i < quantityOfReds; i++) {
           LegoBrick redLegoBrick = new LegoBrick(Color.RED, false);
           myTower.addFirst(redLegoBrick);
           redLegoBrick.isConnected = true;
       }
       for (int i = 0; i < quantityOfYellows; i++) {
           LegoBrick yellowLegoBrick = new LegoBrick(Color.YELLOW, false);
           myTower.addLast(yellowLegoBrick);
           yellowLegoBrick.isConnected = true;
       }
   }

   public void setMyTower(ArrayDeque<legobrick> myTower) {
       this.myTower = myTower;
   }

   public void setQuantityOfReds(int quantityOfReds) {
       this.quantityOfReds = quantityOfReds;
   }

   public void setQuantityOfYellows(int quantityOfYellows) {
       this.quantityOfYellows = quantityOfYellows;
   }

   @Override
   public String toString() {
       return "LegoTower{" +
              "myTower=" + myTower +
              ", quantityOfReds=" + quantityOfReds +
              ", quantityOfYellows=" + quantityOfYellows +
              '}';
   }

   public void drawTower() {
       for (LegoBrick i : myTower) {
           System.out.println(i.color);
       }
   }
}


public class Main {
   public static void main(String[] args) {
       LegoBrick legoBrick1 = new LegoBrick(Color.YELLOW, false);
       legoBrick1.connect();
       System.out.println(legoBrick1.toString());
       legoBrick1.disconnect();
       System.out.println(legoBrick1.toString());
       LegoBrick legoBrick2 = new LegoBrick(Color.YELLOW, false);
       LegoBrick legoBrick3 = new LegoBrick(Color.RED, false);
       LegoBrick legoBrick4 = new LegoBrick(Color.RED, false);
       LegoBrick legoBrick5 = new LegoBrick(Color.YELLOW, false);

       LegoTower legoTower = new LegoTower(2, 5);
       System.out.println("my Initiated Lego Tower: ");
       legoTower.drawTower();
       legoTower.addBrickToTower(legoBrick1);
       legoTower.addBrickToTower(legoBrick2);
       legoTower.addBrickToTower(legoBrick3);
       legoTower.addBrickToTower(legoBrick4);
       legoTower.addBrickToTower(legoBrick5);
       System.out.println("My LegoTower after adding some elements: ");
       legoTower.drawTower();
       legoTower.removeBrickFromTower(legoBrick1);
       legoTower.removeBrickFromTower(legoBrick3);
       System.out.println("We removed one red and one yellow brick:");
       legoTower.drawTower();

   }

}

इस कार्यक्रम को चलाने का नतीजा:

my Initiated LegoTower:

RED
RED
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
My LegoTower after adding some elements:
RED
RED
RED
RED
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
We removed one red and one yellow brick:
RED
RED
RED
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW

Process finished with exit code 0

किसकी प्रतीक्षा?? शीर्ष पर लाल क्यों हैं? नहीं, वे नहीं करते। वे पहले (नीचे) से अंतिम (शीर्ष) तक शुरू होने वाले कंसोल पर प्रिंट आउट करते हैं। इसलिए यदि आप ऊपर की ईंटों के साथ चित्र में कुछ ऐसा देखना चाहते हैं, तो आप लेगोटावर वर्ग की ड्रॉटावर विधि को बदल सकते हैं। यह बहुत ही आसान काम है!

लिंक्ड सूची

सूची इंटरफ़ेस आइटम जोड़ने का क्रम रखता है और इंडेक्स द्वारा आइटम तक पहुंच की अनुमति देता है। Deque एक दो-तरफ़ा कतार है, और यह दोनों ओर से तत्वों को जोड़ने और निकालने का समर्थन करती है। लिंक्डलिस्ट को मुख्य रूप से एक सूची कार्यान्वयन के रूप में जाना जाता है, लेकिन यह वर्ग डेक को भी लागू करता है, और यह हमें एक द्विदिश कतार बनाने की अनुमति देता है जिसमें अशक्त सहित कोई भी वस्तु होती है। लिंक्डलिस्ट तत्वों का एक संग्रह है। हम इसे कक्षा के कोड स्रोत में देख सकते हैं, इस बार फ़ील्ड्स पर ध्यान दें: यहां हम एक उदाहरण जोड़ते हैं, लेकिन यदि आप LinkedList के बारे में अधिक जानना चाहते हैं, तो इस CodeGym लेख में आपका स्वागत है ।

जावा में लिंक्ड सूची कार्यान्वयन, तत्वों को जोड़ना और हटाना। उदाहरण

आइए इन परिचालनों को अभ्यास में आज़माएं। सबसे पहले, जावा लिंक्डलिस्ट कार्यान्वयन: स्ट्रिंग्स की एक लिंक्डलिस्ट बनाना, वहां 3 तत्व जोड़ना। फिर एक को हटाएं, फिर एक को बीच में डालें।

public class MyLinkedTest {
   public static void main(String[] args) {
       String h1 = "my";
       String h2 = "favorite";
       String h3 = "book";
//  LinkedList implementation in Java
       LinkedList<string> linkedList = new LinkedList();
       linkedList.add(h1);
       linkedList.add(h2);
       linkedList.add(h3);
       System.out.println("my list after adding 3 elements:");
       System.out.println(linkedList);
       System.out.println("element #2 of my list:");
       System.out.println(linkedList.get(2));
       linkedList.remove(1);
       System.out.println("my list after removing #1:");
       System.out.println(linkedList);
       linkedList.add(1,"first");
       System.out.println("my list after adding an element in the middle");
       System.out.println(linkedList);
   }

इस कार्यक्रम को चलाने का नतीजा:

my list after adding 3 elements:
[my, favorite, book]
element #2 of my list:
book
my list after removing #1:
[my, book]
my list after adding an element in the middle
[my, first, book]