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

Java Deque ही डेटा रचना आहे जी सामान्य रांग आणि स्टॅक एकत्र करते. तुम्ही डेकच्या डोक्यावर आणि शेपटीला दोन्ही घटक जोडू आणि काढू शकता. "पारंपारिक" रांगेत तुम्ही ओळीच्या शेपटीत घटक जोडता (शेवटच्या घटकानंतर) आणि रांगेच्या डोक्यावरून घटक काढून टाकता. या तत्त्वाला फर्स्ट इन फर्स्ट आउट (FIFO) म्हणतात आणि ते वास्तविक जीवनातील ग्राहकांच्या नेहमीच्या ओळीप्रमाणे कार्य करते. Java Queue मध्ये एक इंटरफेस आहे, जो कलेक्शन फ्रेमवर्कचा एक भाग आहे. स्टॅक नावाची एक महत्त्वाची डेटा स्ट्रक्चर देखील आहे, एक यादी जी पूर्णपणे उलट तत्त्वानुसार घटकांसह कार्य करते, LIFO — लास्ट इन, फर्स्ट आउट. हे प्लेट्सच्या स्टॅकसारखेच आहे, जोडणे किंवा काढणे केवळ शीर्षस्थानीच शक्य आहे.

रांग वि Deque

Deque हा रांगेचा एक विचित्र प्रकार आहे: तुम्ही शेपटी आणि ओळीच्या डोक्यावर नवीन घटक जोडू शकता. काढून टाकण्याची समान कथा: तुम्ही या संरचनेतील शेवटचा किंवा पहिला घटक काढू शकता. म्हणून, हे स्टॅक आणि रांग यांचे मिश्रण असल्याचे दिसते. "Deque" नावाचा अर्थ "डबल एंडेड रांग" आहे. "डेक" चा उच्चार कार्ड्सच्या "डेक" सारखा केला जातो आणि तुम्हाला काय माहित आहे? हे काही प्रमाणात कार्ड्सच्या वास्तविक डेकसारखेच आहे: आपण अशा डेकच्या तळापासून किंवा शीर्षस्थानी कार्ड घेऊ शकता. काही रेखीय संरचनेच्या दोन्ही बाजूंनी घटक जोडू किंवा काढू इच्छिता? Deque वापरा. Java 8 किंवा जवळजवळ इतर कोणतीही आवृत्ती त्यास समर्थन देते. विटांनी बनवलेल्या ठराविक लेगो वीट आणि एक-स्तंभ "टॉवर्स" ची कल्पना करा. आपण टॉवरच्या शीर्षस्थानी किंवा तळाशी एक नवीन वीट जोडू शकता. आपण दोन्ही बाजूंनी एक वीट देखील काढू शकता. येथे आमच्याकडे एक उदाहरण आहे: आम्ही शीर्षस्थानी सर्व पिवळ्या विटा आणि तळाशी सर्व लाल जोडतो. आम्ही हे उदाहरण जावा कोडसह लवकरच प्रदर्शित करू. त्यामुळे तुम्ही जावा डेकच्या दोन्ही टोकांपासून क्यू आणि डीक्यू करू शकता, याचा अर्थ तुम्ही डीक्युचा वापर रांग आणि स्टॅक दोन्ही म्हणून करू शकता. Java मधील स्टॅक बद्दल वाचा: Java Stack 101: स्टॅक क्लासमध्ये प्रवेश करणे Java मधील Queue बद्दल वाचा: Java Queue Interface आणि त्याची अंमलबजावणी

डेकची वैशिष्ट्ये

• Java मधील Deque हा एक इंटरफेस आहे, ज्याची अंमलबजावणी आकार बदलता येण्याजोग्या अॅरेला सपोर्ट प्रदान करते. त्यामुळे तुमच्याकडे निर्बंध-मुक्त क्षमतेची श्रेणी आहे आणि तुम्ही तुमच्या गरजेनुसार नवीन घटक जोडू शकता.
• एकाधिक थ्रेड्सद्वारे समवर्ती प्रवेश Deque द्वारे समर्थित नाही
• बाह्य सिंक्रोनाइझेशनच्या अनुपस्थितीत डेक थ्रेड-सुरक्षित नाही.
• अॅरे डेकमध्ये कोणत्याही शून्य घटकांना अनुमती नाही.

Deque Java इंटरफेस घोषणा

public interface Deque<E> extends Queue<E>

जावा डेक पद्धती

java.util.Deque हा एक इंटरफेस आहे जो Java Queue इंटरफेसचा विस्तार करतो आणि दुहेरी समाप्त रांग दर्शवतो. त्यामुळे Deque सोबत काम करताना तुम्ही Java Queue पद्धती वापरू शकता. Deque स्टॅक इंटरफेसचा विस्तार करत नसतानाही, Deque इंटरफेस अशा पद्धती परिभाषित करतो ज्या तुम्हाला push , peek आणि pop सारख्या ठराविक स्टॅक ऑपरेशन्स करण्यास सक्षम करतात .

• बुलियन अॅड(एलिमेंट) डेकच्या शेपटीला एक घटक जोडते. यशावर खरे परत येते, सध्या जागा उपलब्ध नसल्यास बेकायदेशीर राज्य अपवाद टाकतो.
• addFirst(element) Deque च्या डोक्यावर एक घटक जोडते.
• addLast(element) Deque च्या शेपटीत एक घटक जोडते.
• ऑफर (घटक) शेपटीला एक घटक जोडते आणि समाविष्ट करणे यशस्वी झाले की नाही हे स्पष्ट करण्यासाठी एक बुलियन परत करते.
• ऑफरफर्स्ट(एलिमेंट) हेडमध्ये एक घटक जोडते आणि अंतर्भूत यशस्वी झाले की नाही हे स्पष्ट करण्यासाठी बुलियन परत करते.
• offerLast(element) शेपटीला एक घटक जोडतो आणि समाविष्ट करणे यशस्वी झाले की नाही हे स्पष्ट करण्यासाठी एक बुलियन परत करतो.
• iterator() deque साठी पुनरावृत्ती करणारा परत करतो.
• descendingIterator() एक पुनरावृत्ती करणारा परत करतो ज्यात या deque साठी उलट क्रम आहे.
• पुश(एलिमेंट) डोक्यात एक घटक जोडते.
• pop(element) डोक्यातून एक घटक काढून टाकतो आणि परत करतो.
• removeFirst() डोक्यावरील घटक काढून टाकते.
• removeLast() शेपटातील घटक काढून टाकते.
• poll() या deque द्वारे दर्शविलेल्या रांगेचे प्रमुख पुनर्प्राप्त करते आणि काढून टाकते (दुसर्‍या शब्दात, या deque चा पहिला घटक), किंवा हा deque रिक्त असल्यास शून्य परत करतो.
• pollFirst() या deque चा पहिला घटक पुनर्प्राप्त करतो आणि काढून टाकतो किंवा हा deque रिक्त असल्यास शून्य परत करतो.
• pollLast() या deque चा शेवटचा घटक पुनर्प्राप्त करतो आणि काढून टाकतो किंवा हा deque रिक्त असल्यास शून्य परत करतो.
• peek() पुनर्प्राप्त करते, परंतु काढत नाही, या deque द्वारे दर्शविलेल्या रांगेचे प्रमुख (दुसर्‍या शब्दात, या deque चा पहिला घटक), किंवा हा deque रिकामा असल्यास शून्य परत करते.
• peekFirst() या डीकचा पहिला घटक पुनर्प्राप्त करते, परंतु काढत नाही, किंवा हा deque रिक्त असल्यास शून्य परत करते.
• peekLast() या deque चा शेवटचा घटक पुनर्प्राप्त करते, परंतु काढून टाकत नाही, किंवा हा deque रिकामा असल्यास शून्य परत करते.

येथे खालील तक्त्यामध्ये सर्व पद्धती गटानुसार विभागल्या आहेत. जसे आपण पाहू शकता की घटक जोडण्यासाठी आणि काढण्यासाठी अनेक भिन्न पद्धती आहेत. उदाहरणार्थ, दोन्ही removeFirst() आणि pop() deque मधून पहिला घटक काढून टाकतात. दुसरा स्टॅकमधून “आला”. याचा अर्थ तुम्ही तुमचा ArrayDeque फक्त स्टॅक म्हणून वापरत असल्यास, काढण्यासाठी pop() वापरा, जोडण्यासाठी पुश() आणि तपासण्यासाठी peek() वापरा. हे इतर विकसकांसाठी तुमचा कोड अधिक समंजस बनवते.

Deque अंमलबजावणी

Java Deque एक इंटरफेस आहे आणि Java Collection API मध्ये त्याची अंमलबजावणी आहे:

• java.util.LinkedList //List आणि Deque अंमलबजावणी
• java.util.ArrayDeque //Deque अंमलबजावणी, Java लायब्ररी

LinkedList वर्ग रांग किंवा डेक मॉडेल करण्यासाठी अंतर्गत दुहेरी-लिंक केलेली सूची वापरतो. ArrayDeque वर्ग अ‍ॅरेमध्ये घटक आंतरिकरित्या संग्रहित करतो. जर घटकांची संख्या अॅरेच्या व्हॉल्यूमपेक्षा जास्त असेल तर, नवीन अॅरे वाटप केले जाते आणि सर्व घटक हलवले जातात. याचा अर्थ ArrayDeque गरजेनुसार वाढतो.

ArrayDeque वर्ग

ArrayDeque <E> क्लास ही एक सामान्य दोन दिशात्मक रांग आहे, जी AbstractCollection क्लासमधून इनहेरिट केलेली कार्यक्षमता आणि Deque इंटरफेस वापरते. ArrayDeque deque आणि resizable-array वापरण्याची सुविधा प्रदान करते. सुरुवातीला, अ‍ॅरे आकार 16 सह आरंभ केला जातो. हे द्वि-मार्ग रांगेत लागू केले जाते, जेथे ते डोके आणि शेपूट या दोन पॉइंटर्सना समर्थन देते. हे AbstractCollection क्लास इनहेरिट करते आणि Deque इंटरफेस लागू करते. ArrayDeque वर्गाचे महत्त्वाचे मुद्दे आहेत:

• तुम्ही शेपटी आणि ArrayDeque च्या डोक्यावरून घटक जोडू किंवा काढू शकता
• शून्य घटकांना परवानगी नाही
• बाह्य सिंक्रोनाइझेशनच्या अनुपस्थितीत, ArrayDeque थ्रेड सुरक्षित नाही.
• ArrayDeque मध्ये क्षमता निर्बंध नाहीत.

ArrayDeque वर्ग कन्स्ट्रक्टर

• ArrayDeque() रिकामी रांग तयार करते.
• ArrayDeque (संकलन <? E> संग्रह वाढवते) संग्रह संकलन घटकांनी भरलेली रांग तयार करते.
• ArrayDeque (int क्षमता) प्रारंभिक क्षमता क्षमतेसह एक रांग तयार करते . तुम्ही प्रारंभिक क्षमता निर्दिष्ट न केल्यास, डीफॉल्ट क्षमता 16 आहे.

Java Deque उदाहरण - 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 हे मुख्यत्वे सूची अंमलबजावणी म्हणून ओळखले जाते, परंतु हा वर्ग Deque देखील लागू करतो आणि तो आम्हाला शून्यासह कोणत्याही वस्तूंचा समावेश असलेली द्विदिशात्मक रांग तयार करण्यास अनुमती देतो. LinkedList हा घटकांचा संग्रह आहे. आम्ही ते वर्गाच्या कोड स्त्रोतामध्ये पाहू शकतो, यावेळी फील्डकडे लक्ष द्या: येथे आम्ही एक उदाहरण जोडतो, परंतु तुम्हाला LinkedList बद्दल अधिक जाणून घ्यायचे असल्यास, या CodeGym लेखात स्वागत आहे .

Java मध्ये लिंक्ड सूची अंमलबजावणी, घटक जोडणे आणि काढून टाकणे. उदाहरण

चला सरावाने या ऑपरेशन्सचा प्रयत्न करूया. प्रथम, Java LinkedList अंमलबजावणी: स्ट्रिंग्सची LinkedList तयार करणे, तेथे 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]