Java Deque అనేది సాధారణ క్యూ మరియు స్టాక్‌లను మిళితం చేసే డేటా నిర్మాణం. మీరు డిక్యూ యొక్క తల మరియు తోకకు రెండు మూలకాలను జోడించవచ్చు మరియు తీసివేయవచ్చు. "సాంప్రదాయ" క్యూలో మీరు లైన్ యొక్క తోకకు (చివరి మూలకం తర్వాత) మూలకాలను జోడించి, క్యూ యొక్క తల నుండి మూలకాలను తీసివేయండి. ఈ సూత్రాన్ని ఫస్ట్ ఇన్ ఫస్ట్ అవుట్ (FIFO) అని పిలుస్తారు మరియు ఇది నిజ జీవితంలో కస్టమర్ల సాధారణ లైన్ లాగా పనిచేస్తుంది. జావా క్యూలో ఒక ఇంటర్ఫేస్, కలెక్షన్స్ ఫ్రేమ్‌వర్క్‌లో ఒక భాగం. స్టాక్ అనే ముఖ్యమైన డేటా స్ట్రక్చర్ కూడా ఉంది, ఇది పూర్తిగా రివర్స్ సూత్రం, LIFO - లాస్ట్ ఇన్, ఫస్ట్ అవుట్‌లో ఎలిమెంట్‌లతో పనిచేసే జాబితా. ఇది ప్లేట్ల స్టాక్‌ను పోలి ఉంటుంది, జోడించడం లేదా తీసివేయడం పైభాగంలో మాత్రమే సాధ్యమవుతుంది.
క్యూ vs డెక్యూ
Deque అనేది చాలా విచిత్రమైన క్యూ రకం: మీరు లైన్ యొక్క టెయిల్ మరియు హెడ్‌కి కొత్త ఎలిమెంట్‌లను జోడించవచ్చు. తీసివేయడంతో అదే కథనం: మీరు ఈ నిర్మాణం నుండి చివరి లేదా మొదటి మూలకాన్ని తీసివేయవచ్చు. అందువల్ల, ఇది స్టాక్ మరియు క్యూల మిశ్రమంగా కనిపిస్తుంది. "డెక్" అనే పేరు "డబుల్ ఎండెడ్ క్యూ" అని అర్థం. "Deque" అనేది కార్డుల "డెక్" లాగా ఉచ్ఛరిస్తారు మరియు మీకు ఏమి తెలుసు? ఇది కార్డుల యొక్క నిజమైన డెక్‌కి కొంతవరకు సారూప్యంగా ఉంటుంది: మీరు అటువంటి డెక్ యొక్క దిగువ నుండి లేదా పైభాగం నుండి కార్డును తీసుకోవచ్చు. కొన్ని లీనియర్ స్ట్రక్చర్ యొక్క రెండు వైపుల నుండి ఎలిమెంట్‌లను జోడించాలనుకుంటున్నారా లేదా తీసివేయాలనుకుంటున్నారా? Deque ఉపయోగించండి. జావా 8 లేదా దాదాపు ఏదైనా ఇతర వెర్షన్ దీనికి మద్దతు ఇస్తుంది. ఇటుకలతో తయారు చేయబడిన ఒక సాధారణ లెగో ఇటుక మరియు ఒక-కాలమ్ "టవర్లు" ఇమాజిన్ చేయండి. మీరు టవర్ పైభాగానికి లేదా దిగువకు కొత్త ఇటుకను జోడించవచ్చు. మీరు రెండు వైపుల నుండి ఒక ఇటుకను కూడా తీసివేయవచ్చు. ఇక్కడ మనకు ఒక ఉదాహరణ ఉంది: మేము అన్ని పసుపు ఇటుకలను ఎగువకు మరియు అన్ని ఎరుపులను దిగువకు కలుపుతాము. మేము ఈ ఉదాహరణను జావా కోడ్‌తో త్వరలో ప్రదర్శిస్తాము. కాబట్టి మీరు జావా డీక్యూ యొక్క రెండు చివరల నుండి ఎన్క్యూ మరియు డీక్యూ చేయవచ్చు, అంటే మీరు క్యూ మరియు స్టాక్ రెండింటిలోనూ డీక్యూని ఉపయోగించవచ్చు. జావాలో స్టాక్ గురించి చదవండి: జావా స్టాక్ 101: స్టాక్ క్లాస్‌లోకి ప్రవేశించడం జావాలో క్యూ గురించి చదవండి: జావా క్యూ ఇంటర్ఫేస్ మరియు దాని అమలులు
Deque యొక్క లక్షణాలు
Javaలోని Deque అనేది ఒక ఇంటర్ఫేస్, ఇది రీసైజ్ చేయదగిన శ్రేణికి మద్దతునిస్తుంది. కాబట్టి మీరు పరిమితి-రహిత సామర్థ్యం యొక్క శ్రేణిని కలిగి ఉన్నారు మరియు మీరు మీ అవసరాలకు అనుగుణంగా కొత్త అంశాలను జోడించవచ్చు.
బహుళ థ్రెడ్‌ల ద్వారా ఏకకాల యాక్సెస్‌కు Deque మద్దతు లేదు
బాహ్య సమకాలీకరణ లేనప్పుడు Deque థ్రెడ్-సురక్షితమైనది కాదు.
శ్రేణి dequeలో శూన్య మూలకాలు ఏవీ అనుమతించబడవు.
Deque జావా ఇంటర్ఫేస్ డిక్లరేషన్
public interface Deque<E> extends Queue<E>
జావా డెక్యూ పద్ధతులు
java.util.Deque అనేది జావా క్యూ ఇంటర్‌ఫేస్‌ను విస్తరించే ఇంటర్ఫేస్ మరియు డబుల్ ఎండెడ్ క్యూను సూచిస్తుంది. కాబట్టి మీరు Dequeతో పని చేస్తున్నప్పుడు అన్ని జావా క్యూ పద్ధతులను ఉపయోగించవచ్చు. Deque స్టాక్ ఇంటర్‌ఫేస్‌ను పొడిగించనప్పటికీ, Deque ఇంటర్ఫేస్ పుష్ , పీక్ మరియు పాప్ వంటి సాధారణ స్టాక్ ఆపరేషన్‌లను చేయడానికి మిమ్మల్ని అనుమతించే పద్ధతులను నిర్వచిస్తుంది .
బూలియన్ యాడ్(మూలకం) డీక్యూ యొక్క తోకకు ఒక మూలకాన్ని జోడిస్తుంది. విజయం సాధించినప్పుడు నిజమని చూపుతుంది, ప్రస్తుతం ఖాళీ అందుబాటులో లేకుంటే చట్టవిరుద్ధమైన రాష్ట్ర మినహాయింపును విసిరివేస్తుంది.
addFirst(మూలకం) Deque యొక్క తలపై ఒక మూలకాన్ని జోడిస్తుంది.
addLast(మూలకం) Deque యొక్క తోకకు ఒక మూలకాన్ని జోడిస్తుంది.
ఆఫర్(మూలకం) తోకకు ఒక మూలకాన్ని జోడిస్తుంది మరియు చొప్పించడం విజయవంతమైందో లేదో వివరించడానికి బూలియన్‌ను అందిస్తుంది.
offerFirst(మూలకం) తలపై ఒక మూలకాన్ని జోడిస్తుంది మరియు చొప్పించడం విజయవంతమైందో లేదో వివరించడానికి బూలియన్‌ను అందిస్తుంది.
offerLast(మూలకం) తోకకు ఒక మూలకాన్ని జోడిస్తుంది మరియు చొప్పించడం విజయవంతమైందో లేదో వివరించడానికి బూలియన్‌ను అందిస్తుంది.
iterator() deque కోసం ఇటరేటర్‌ని అందిస్తుంది.
descendingIterator() ఈ డిక్యూ కోసం రివర్స్ ఆర్డర్‌ని కలిగి ఉన్న ఇటరేటర్‌ని అందిస్తుంది.
పుష్(మూలకం) తలకు ఒక మూలకాన్ని జోడిస్తుంది.
పాప్(మూలకం) తల నుండి ఒక మూలకాన్ని తీసివేసి దానిని తిరిగి ఇస్తుంది.
removeFirst() తల వద్ద ఉన్న మూలకాన్ని తొలగిస్తుంది.
removeLast() తోక వద్ద ఉన్న మూలకాన్ని తొలగిస్తుంది.
పోల్() ఈ డీక్యూ ద్వారా సూచించబడిన క్యూ యొక్క హెడ్‌ని తిరిగి పొందుతుంది మరియు తీసివేస్తుంది (ఇతర మాటలలో, ఈ డీక్యూ యొక్క మొదటి మూలకం), లేదా ఈ డీక్యూ ఖాళీగా ఉంటే శూన్యతను అందిస్తుంది.
pollFirst() ఈ deque యొక్క మొదటి మూలకాన్ని తిరిగి పొందుతుంది మరియు తీసివేస్తుంది లేదా ఈ deque ఖాళీగా ఉంటే శూన్యతను అందిస్తుంది.
pollLast() ఈ deque యొక్క చివరి మూలకాన్ని తిరిగి పొందుతుంది మరియు తీసివేస్తుంది లేదా ఈ deque ఖాళీగా ఉంటే శూన్యతను అందిస్తుంది.
పీక్() ఈ డీక్యూ ద్వారా సూచించబడిన క్యూ యొక్క హెడ్‌ని తిరిగి పొందుతుంది, కానీ తీసివేయదు (మరో మాటలో చెప్పాలంటే, ఈ డీక్యూ యొక్క మొదటి మూలకం), లేదా ఈ డీక్యూ ఖాళీగా ఉంటే శూన్యతను అందిస్తుంది.
peekFirst() ఈ deque యొక్క మొదటి మూలకాన్ని తిరిగి పొందుతుంది, కానీ తీసివేయదు, లేదా ఈ deque ఖాళీగా ఉంటే శూన్యతను అందిస్తుంది.
peekLast() ఈ deque యొక్క చివరి మూలకాన్ని తిరిగి పొందుతుంది, కానీ తీసివేయదు, లేదా ఈ deque ఖాళీగా ఉంటే శూన్యతను అందిస్తుంది.
ఇక్కడ దిగువ పట్టికలో అన్ని పద్ధతులు సమూహాల ద్వారా విభజించబడ్డాయి. మీరు చూడగలిగినట్లుగా ఒక మూలకాన్ని జోడించడానికి మరియు తీసివేయడానికి అనేక విభిన్న పద్ధతులు ఉన్నాయి. ఉదాహరణకు, removeFirst() మరియు pop() రెండూ deque నుండి మొదటి మూలకాన్ని తీసివేస్తాయి. రెండవది స్టాక్ నుండి "వచ్చింది". అంటే మీరు మీ ArrayDequeని స్టాక్‌గా మాత్రమే ఉపయోగిస్తే, తీసివేయడానికి పాప్()ని, జోడించడానికి పుష్() మరియు పరిశీలించడానికి పీక్()ని ఉపయోగించండి. ఇది మీ కోడ్‌ను ఇతర డెవలపర్‌లకు మరింత సరైనదిగా చేస్తుంది.
మొదటి మూలకం (తల)
చివరి మూలకం (తోక)
ఆపరేషన్
మినహాయింపు విసురుతాడు
ప్రత్యేక విలువ
మినహాయింపు విసురుతాడు
ప్రత్యేక విలువ
చొప్పించడం
addFirst(e)/push(e)
ఆఫర్ ఫస్ట్(ఇ)
addLast(e)
ఆఫర్ చివరి()
తొలగించు
తొలిగించు()/పాప్()
పోల్ ఫస్ట్()
తొలగించు చివరి()
పోల్ లాస్ట్()
పరిశీలించండి
getFirst()
పీక్ ఫస్ట్()/పీక్()
getLast()
పీక్ లాస్ట్()
Deque అమలులు
Java Deque ఒక ఇంటర్ఫేస్ మరియు జావా కలెక్షన్స్ APIలో అమలులను కలిగి ఉంది:
java.util.LinkedList //జాబితా మరియు డీక్యూ అమలు
java.util.ArrayDeque //Deque అమలు, జావా లైబ్రరీ
లింక్డ్లిస్ట్ క్లాస్ క్యూ లేదా డీక్యూని మోడల్ చేయడానికి అంతర్గతంగా డబుల్-లింక్డ్ జాబితాను ఉపయోగిస్తుంది. ArrayDeque క్లాస్ మూలకాలను అంతర్గతంగా శ్రేణిలో నిల్వ చేస్తుంది. మూలకాల సంఖ్య శ్రేణి యొక్క వాల్యూమ్‌ను మించి ఉంటే, కొత్త శ్రేణి కేటాయించబడుతుంది మరియు అన్ని మూలకాలు తరలించబడతాయి. అంటే ArrayDeque అవసరాలను బట్టి పెరుగుతుంది.
ArrayDeque తరగతి
ArrayDeque <E> క్లాస్ అనేది సాధారణ రెండు డైరెక్షనల్ క్యూ, ఇది అబ్‌స్ట్రాక్ట్ కలెక్షన్ క్లాస్ నుండి ఫంక్షనాలిటీని పొందుతుంది మరియు డీక్యూ ఇంటర్‌ఫేస్‌ని ఉపయోగిస్తుంది. ArrayDeque deque మరియు resizable-arrayని ఉపయోగించే సౌకర్యాన్ని అందిస్తుంది. ప్రారంభంలో, శ్రేణి పరిమాణం 16తో ప్రారంభించబడింది. ఇది రెండు-మార్గం క్యూ వలె అమలు చేయబడుతుంది, ఇక్కడ ఇది తల మరియు తోక అనే రెండు పాయింటర్‌లకు మద్దతు ఇస్తుంది. ఇది అబ్‌స్ట్రాక్ట్ కలెక్షన్ క్లాస్‌ను వారసత్వంగా పొందుతుంది మరియు డీక్యూ ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది. ArrayDeque తరగతి గురించి ముఖ్యమైన అంశాలు:
మీరు ArrayDeque యొక్క టెయిల్ మరియు హెడ్ నుండి ఎలిమెంట్‌లను జోడించవచ్చు లేదా తీసివేయవచ్చు
శూన్య అంశాలు అనుమతించబడవు
బాహ్య సమకాలీకరణ లేనప్పుడు ArrayDeque థ్రెడ్ సురక్షితం కాదు.
ArrayDequeకి సామర్థ్య పరిమితులు లేవు.
ArrayDeque క్లాస్ కన్‌స్ట్రక్టర్స్
ArrayDeque() ఖాళీ క్యూను సృష్టిస్తుంది.
ArrayDeque (కలెక్షన్ <? E> సేకరణను పొడిగిస్తుంది) సేకరణ సేకరణ అంశాలతో నిండిన క్యూను సృష్టిస్తుంది.
ArrayDeque (పూర్ణాంక సామర్థ్యం) ప్రారంభ సామర్థ్య సామర్థ్యంతో క్యూను సృష్టిస్తుంది . మీరు ప్రారంభ సామర్థ్యాన్ని పేర్కొనకపోతే, డిఫాల్ట్ సామర్థ్యం 16.
జావా డీక్యూ ఉదాహరణ - అర్రేడీక్యూ
వ్యాసం ప్రారంభం నుండి లెగో టవర్ ఉదాహరణ గుర్తుందా? లెగో బ్రిక్స్‌తో తయారు చేసిన ఒక-కాలమ్ టవర్‌లను నిర్మించడానికి ఒక తరగతిని సృష్టిద్దాం. ఇటుకలు ఎరుపు, పసుపు లేదా నీలం కావచ్చు. మా టవర్ నిర్మాణ నియమం: మేము ఎర్ర ఇటుకలను దిగువకు మరియు పసుపు ఇటుకలను పైకి ఉంచాము. బిగ్ జావా డిక్యూ ఉదాహరణ
//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
ఆగండి, ఏంటి?? పైన రెడ్లు ఎందుకు ఉన్నారు? లేదు, వారు చేయరు. వారు కేవలం మొదటి (దిగువ) నుండి చివరి (ఎగువ) వరకు కన్సోల్‌కు ముద్రించారు. కాబట్టి మీరు పైన ఉన్న ఇటుకలతో చిత్రంలో ఉన్నట్లుగా చూడాలనుకుంటే, మీరు LegoTower తరగతి యొక్క డ్రా టవర్ పద్ధతిని మార్చవచ్చు. ఇది చాలా సులభమైన పని!
లింక్డ్లిస్ట్
జాబితా ఇంటర్ఫేస్ ఐటెమ్‌లను జోడించే క్రమాన్ని ఉంచుతుంది మరియు ఇండెక్స్ ద్వారా ఐటెమ్‌కు యాక్సెస్‌ను అనుమతిస్తుంది. Deque అనేది రెండు-మార్గం క్యూ, మరియు ఇది రెండు వైపుల నుండి ఎలిమెంట్‌లను జోడించడానికి మరియు తీసివేయడానికి మద్దతు ఇస్తుంది. లింక్డ్లిస్ట్ ప్రధానంగా జాబితా అమలుగా పిలువబడుతుంది, కానీ ఈ తరగతి Dequeని అమలు చేస్తుంది మరియు ఇది శూన్యంతో సహా ఏవైనా వస్తువులతో కూడిన ద్వి దిశాత్మక క్యూను సృష్టించడానికి అనుమతిస్తుంది. లింక్డ్లిస్ట్ అనేది మూలకాల సమాహారం. మేము దానిని తరగతి కోడ్ సోర్స్‌లో చూడవచ్చు, ఈసారి ఫీల్డ్‌లపై శ్రద్ధ వహించండి: ఇక్కడ మేము ఒక ఉదాహరణను జోడిస్తాము, కానీ మీరు లింక్డ్లిస్ట్ గురించి మరింత తెలుసుకోవాలనుకుంటే, ఈ కోడ్‌జిమ్ కథనానికి స్వాగతం .
జావాలో లింక్ చేయబడిన జాబితా అమలు, మూలకాలను జోడించడం మరియు తీసివేయడం. ఉదాహరణ
ఆచరణలో ఈ కార్యకలాపాలను ప్రయత్నిద్దాం. ముందుగా, జావా లింక్డ్లిస్ట్ అమలు: లింక్డ్ లిస్ట్ ఆఫ్ స్ట్రింగ్‌లను సృష్టించడం, అక్కడ 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]
స్టాక్ అనే ముఖ్యమైన డేటా స్ట్రక్చర్ కూడా ఉంది, ఇది పూర్తిగా రివర్స్ సూత్రం, LIFO - లాస్ట్ ఇన్, ఫస్ట్ అవుట్‌లో ఎలిమెంట్‌లతో పనిచేసే జాబితా. ఇది ప్లేట్ల స్టాక్‌ను పోలి ఉంటుంది, జోడించడం లేదా తీసివేయడం పైభాగంలో మాత్రమే సాధ్యమవుతుంది. 
"డెక్" అనే పేరు "డబుల్ ఎండెడ్ క్యూ" అని అర్థం. "Deque" అనేది కార్డుల "డెక్" లాగా ఉచ్ఛరిస్తారు మరియు మీకు ఏమి తెలుసు? ఇది కార్డుల యొక్క నిజమైన డెక్‌కి కొంతవరకు సారూప్యంగా ఉంటుంది: మీరు అటువంటి డెక్ యొక్క దిగువ నుండి లేదా పైభాగం నుండి కార్డును తీసుకోవచ్చు. కొన్ని లీనియర్ స్ట్రక్చర్ యొక్క రెండు వైపుల నుండి ఎలిమెంట్‌లను జోడించాలనుకుంటున్నారా లేదా తీసివేయాలనుకుంటున్నారా? Deque ఉపయోగించండి. జావా 8 లేదా దాదాపు ఏదైనా ఇతర వెర్షన్ దీనికి మద్దతు ఇస్తుంది. ఇటుకలతో తయారు చేయబడిన ఒక సాధారణ లెగో ఇటుక మరియు ఒక-కాలమ్ "టవర్లు" ఇమాజిన్ చేయండి. మీరు టవర్ పైభాగానికి లేదా దిగువకు కొత్త ఇటుకను జోడించవచ్చు. మీరు రెండు వైపుల నుండి ఒక ఇటుకను కూడా తీసివేయవచ్చు. ఇక్కడ మనకు ఒక ఉదాహరణ ఉంది: మేము అన్ని పసుపు ఇటుకలను ఎగువకు మరియు అన్ని ఎరుపులను దిగువకు కలుపుతాము. మేము ఈ ఉదాహరణను జావా కోడ్‌తో త్వరలో ప్రదర్శిస్తాము. 
కాబట్టి మీరు జావా డీక్యూ యొక్క రెండు చివరల నుండి ఎన్క్యూ మరియు డీక్యూ చేయవచ్చు, అంటే మీరు క్యూ మరియు స్టాక్ రెండింటిలోనూ డీక్యూని ఉపయోగించవచ్చు. జావాలో స్టాక్ గురించి చదవండి: జావా స్టాక్ 101: స్టాక్ క్లాస్‌లోకి ప్రవేశించడం జావాలో క్యూ గురించి చదవండి: జావా క్యూ ఇంటర్ఫేస్ మరియు దాని అమలులు
లింక్డ్లిస్ట్ క్లాస్ క్యూ లేదా డీక్యూని మోడల్ చేయడానికి అంతర్గతంగా డబుల్-లింక్డ్ జాబితాను ఉపయోగిస్తుంది. ArrayDeque క్లాస్ మూలకాలను అంతర్గతంగా శ్రేణిలో నిల్వ చేస్తుంది. మూలకాల సంఖ్య శ్రేణి యొక్క వాల్యూమ్‌ను మించి ఉంటే, కొత్త శ్రేణి కేటాయించబడుతుంది మరియు అన్ని మూలకాలు తరలించబడతాయి. అంటే ArrayDeque అవసరాలను బట్టి పెరుగుతుంది.
లింక్డ్లిస్ట్ ప్రధానంగా జాబితా అమలుగా పిలువబడుతుంది, కానీ ఈ తరగతి Dequeని అమలు చేస్తుంది మరియు ఇది శూన్యంతో సహా ఏవైనా వస్తువులతో కూడిన ద్వి దిశాత్మక క్యూను సృష్టించడానికి అనుమతిస్తుంది. లింక్డ్లిస్ట్ అనేది మూలకాల సమాహారం. మేము దానిని తరగతి కోడ్ సోర్స్‌లో చూడవచ్చు, ఈసారి ఫీల్డ్‌లపై శ్రద్ధ వహించండి: ఇక్కడ మేము ఒక ఉదాహరణను జోడిస్తాము, కానీ మీరు లింక్డ్లిస్ట్ గురించి మరింత తెలుసుకోవాలనుకుంటే, ఈ కోడ్‌జిమ్ కథనానికి స్వాగతం .
GO TO FULL VERSION