Wir wurden zuvor mehreren Datenstrukturen ausgesetzt, darunter Arrays, verknüpfte Listen, Hash -Tabellen sowie rote und schwarze Bäume (binäre Abfragebäume). Schauen wir uns heute eine andere Datenstruktur an: Stack.
Was ist ein Stapel? Schauen wir uns zunächst ein Beispiel an: Ein Stapel entspricht einem sehr schmalen Holzfass. Wenn wir die Dinge in das Holzfass stecken und die Dinge herausnehmen, werden wir feststellen, dass das, was wir am Anfang auf den Grund stellen, und das erste, was wir herausgenommen haben, das, was wir gerade eingesetzt haben. Deshalb ist der Stapel ein solcher Behälter, der zuerst ein- und aus (FirstinLastout oder später in und zuerst). Es hat nur einen Mund, steckt Elemente in diesen Mund und nimmt auch Elemente in diesen Mund heraus. Dann lernen wir als nächstes den Stapel in JDK.
1. Grundlegende Einführung und Verwendung von Vector & Stack
Schauen wir uns zunächst die Definition von JDK an:
öffentliche Klasse Stack <E> erweitert Vector <e> {Aus dem obigen Punkt können wir sehen, dass Stack von Vector geerbt wird, sodass wir auch ein gewisses Verständnis von Vector haben müssen.
Vektor: Dynamische Arrays mit Thread-Sicherheit
Stack: Erbenvektor, ein thread-sicherer Stack, der basierend auf dynamischen Arrays implementiert ist;
1. Merkmale von Vektor und Stapel:
Vektor und ArrayList sind im Grunde gleich. Der Unterschied besteht darin, dass der Vektor thread-sicher ist und das synchronisierte Schlüsselwort vor den möglichen thread-sffe-Methoden hinzufügt.
Vektor: Schnelle Zufallszugriffsgeschwindigkeit, schlechte Einfügung und Entfernungsleistung (Eigenschaften des Arrays); unterstützt Nullelemente; hat Ordnung; Elemente können wiederholt werden; thread-safe;
Stack: After-In, First-Out, implementiert einige grundlegende Stapeloperationsmethoden (in der Tat ist es nicht nur nach dem In-in, zuerst, weil es von Vector geerbt wird, es kann viele Operationen geben, und in gewissem Sinne ist es kein Stapel).
2.Vektor- und Stapelstruktur:
Vektorklasse
Es ist im Grunde genommen das gleiche wie ArrayList, und die verbleibenden Hauptunterschiede sind wie folgt:
1. Vektor ist fadensicher
2. Das Wachstum des ArrayList ist mit dem Vektorwachstum nicht übereinstimmend
Andere, wenn die Konstruktionsmethoden inkonsistent sind, kann Vektor die Kapazitätsinkremente durch die Konstruktionsmethode initialisieren, und es gibt andere Methoden wie die Index -Methode. Vector unterstützt die Suche und Suche vom angegebenen Ort. Darüber hinaus verfügt Vector über einige redundante Methoden mit doppelten Funktionen wie der Addelement- und SetElementat -Methode. Der Grund dafür liegt auf historischen Gründen. Beispielsweise wird die Addelement -Methode zuvor zurückgelassen. Als das Sammelframework eingeführt wurde, trat Vector der Sammlungsfamilie bei und änderte sich, um die Listenschnittstelle zu implementieren. Einige in der Listenschnittstelle definierte Methoden müssen implementiert werden. Aus Kompatibilitätsgründen können die alten Methoden jedoch nicht gelöscht werden, sodass einige alte Methoden mit Redundanz erschienen. Jetzt wurde es durch ArrayList ersetzt und wird im Grunde genommen selten verwendet, also verstehen Sie einfach.
Stapelklasse
Der grundlegende Betrieb des Stapels wird realisiert. Die Methode lautet wie folgt:
öffentlicher Stack ();
Erstellen Sie einen leeren Stapel
öffentliche synchronisierte e peek ();
Gibt den Wert oben am Stapel zurück;
public e push (e item);
Stapelbetrieb;
öffentlich synchronisierte e pop ();
Out-Stack-Betrieb;
öffentlich boolean leer ();
Stellen Sie fest, ob der Stapel leer ist;
öffentliche synchronisierte Int -Suche (Objekt O);
Gibt die Position des Objekts im Stapel zurück;
Für den obigen Stapel verwenden wir im Grunde nur die obige Methode häufig. Obwohl es Vektor erbt und viele Methoden hat, wird es im Grunde genommen nicht verwendet, aber es wird nur als Stapel behandelt.
3. Grundnutzung
Einige Methoden im Vektor werden wie folgt verwendet. Darüber hinaus entspricht die Traversal -Methode des Vektors der von ArrayList. Sie können foreach, Iterator und für Loop -Traversal verwenden.
Import Java.util.Arrays; Import Java.util.iterator; Import Java.util.List; Import Java.util.Listiterator; Import Java.util.Vector; öffentlicher Klassen -Test {public static void main (String [] args) {vector <integer> vector = new vector <integer> (); für (int i = 0; i <10; i ++) {vector.add (i); } // print system.out.println (vector.toString ()); // size () system.out.println (vector.size ()); // enthält system.out.println (vector.contains (2)); // Iterator Iterator <Ganzzahl> iterator = vector.iterator (); while (iterator.hasnext ()) {System.out.print (iterator.next () + ""); } // toArray Object [] objarr = vector.toArray (); System.out.println ("/nobjarr:" + arrays.aslist (objarr)); Integer [] intarr = vector.toArray (New Integer [vector.size ()]); System.out.println ("intarr:" + arrays.aslist (intarr)); // vector.add (5) hinzufügen; // Vektor entfernen.Remove (5); System.out.println (Vektor); // enthält // addall vector.addall (arrays.aslist (555,666)); System.out.println (Vektor); // removeall vector.removeall (arrays.aslist (555,666)); System.out.println (Vektor); // Addall Method Vector.addall (5, Arrays.aslist (666,666, 6)); System.out.println (Vektor); // method system.out.println (vector.get (5)) erhalten; // Methode vector.set (5, 55); System.out.println (vector.get (5)); // Methode vector.add (0, 555) hinzufügen; System.out.println (Vektor); // Methode Vector entfernen.Remove (0); System.out.println (Vektor); // indexof method System.out.println (vector.indexof (6)); // lastIndexof method system.out.println (vector.lastindexof (6)); // ListIterator -Methode Listiterator <Ganzzahl> listiterator = vector.listIterator (); System.out.println (listiterator.hasprevious ()); // Listiterator (Index) Methode Listiterator <Ganzzahl> ilistiterator = vector.listiterator (5); System.out.println (ilistiterator.previous ()); // Sublist Method System.out.println (Vector.Sublist (5, 7)); // Clear vector.clear (); System.out.println (Vektor); }}Einige Methoden im Stack werden wie folgt verwendet. Da Stack Vector erbt, kann Stack auch Methoden verwenden, die Vektor anwenden können. Im Folgenden werden einige Beispiele für die einzigartigen Methoden von Stack aufgeführt. Es ist sehr einfach, die einige grundlegende Operationen des Stapels sind. Zusätzlich zu mehreren Traversalmethoden von Vektor verfügt Stack auch über seine eigenen einzigartigen Durchgangsmethoden (unter Verwendung der leeren Methode und der POP -Methode, um die Fahrt von oben nach unten im Stapel zu erreichen):
Java.util.stack; public class test {public static void main (String [] args) {Stack <GanzEger> Stack = new Stack <GanzEger> (); für (int i = 0; i <10; i ++) {stack.add (i); } System.out.println (Stack); System.out.println (stack.peek ()); Stack.push (555); System.out.println (Stack); System.out.println (stack.pop ()); System.out.println (Stack); System.out.println (stack.empty ()); System.out.println (stack.search (6)); System.out.println ("Stack Traversal:"); while (! stack.empty ()) {System.out.print (stack.pop () + ""); }}}Unterabschnitt:
Vektor ist thread-sicher, hat aber eine schlechte Leistung. Im Allgemeinen wird ArrayList verwendet, es sei denn, es gibt spezielle Anforderungen.
Wenn Sie den Stapel als Stapel verwenden möchten, sollten Sie ehrlich und streng den verschiedenen Operationen des Stapels befolgen. Andernfalls wäre es sinnvoll, Stack zu verwenden, und es wäre besser, Vektor zu verwenden.
2. Vector & Stackes Struktur und zugrunde liegende Speicherung
Public Class Vector <e> erweitert AbstractList <E> implementiert List <E>, RandomAccess, klonbar, java.io.serializable
Vector ist eine Implementierungsklasse von Listen. Tatsächlich ist Vector auch ein Listencontainer, der auf der Array -Implementierung basiert. Die Funktionen und der Implementierungscode sind im Grunde genommen mit ArrayList überein. Also, was ist anders? Eine davon ist, dass der Vektor *2 und die ArrayList *1,5+1 beträgt, wenn das Array erweitert wird; Der andere ist, dass Vector thread-sicher ist, während ArrayList nicht ist. Der Thread-safe-Ansatz von Vektor besteht darin, jeder Methode ein synchronisiertes Schlüsselwort hinzuzufügen, um es sicherzustellen. Aber hier wird Vector nicht mehr offiziell (von allen anerkannt) und wird nicht empfohlen. Es liegt offiziell daran, dass seine Fadensicherheitsmethode darin besteht, die gesamte Methode zu sperren, was zu einer geringen Effizienz führt. Gibt es also eine bessere Lösung? In der Tat kann nicht gesagt werden, dass es einen gibt, aber es gibt wirklich eine, Sammlungen.SynchronizedList ()
Da Stack geerbt und auf Vektor basiert, schauen wir uns einige Definitionen und Methodenquellencodes von Vektor an:
// Die zugrunde liegende Ebene verwendet ein Array, um daten geschützte Objekte [] elementData zu speichern. // die Anzahl der Elemente geschützt int elementCount; // Anpassen der Containerausdehnung und der inkrements geschützten Int -Kapazitätsinkrements; public vector (int initialCapacity, int capacityIncrement) {Super (); // Beendigung Grenzen prüfen, ob (initialCapacity <0) neue IllegalArgumentException ("illegale Kapazität:" + initialCapacity) werfen; // Initialisieren Sie das Array this.elementData = neues Objekt [initialCapacity]; this.capacityIncrement = capacityIncrement; } // Verwenden Sie die synchronisierte Keyword -Sperre -Methode, um sicherzustellen, dass nur ein Thread die Methode gleichzeitig manipulieren kann. // Vergrößerungsprüfung tealEcapacityHelper (elementCount + 1); elementData [elementCount ++] = e; zurückkehren; } private void sealecapacityHelper (int mincapacity) {// Aktuelle Anzahl der Elemente int oldcapacity = elementData .Length; // ist notwendig, die Kapazität zu erweitern, wenn (mincapacity> OldCapacity) {Object [] oldData = elementData; // Wenn die Containererweiterung angepasst wird, erweitern Sie die Kapazität nach Kapazitätsinkrement, andernfalls erweitern Sie die Kapazität um zweimal (*2) int newCapacity = (CAPAPYINCREMENT> 0)? (OldCapacity + CAPAPY INCREMENT): (OldCapacity * 2); if (newCapacity <mincapacity) {newCapacity = mincapacity; } // Array Copy ElementData = arrays.copyof (elementData, NewCapacity); }}Vektor sehen das einfach. Wenn die andere Stack -Methode nicht aufgerufen wird, wird sie nicht analysiert. Wenn Sie es nicht verstehen, können Sie die Analyse der ArrayList -Quellcode überprüfen.
3.. Analyse der Hauptmethoden
1.Peek () - Holen Sie sich das Objekt oben am Stapel
/ ** * Holen Sie das Objekt oben im Stapel, löschen Sie jedoch nicht */ public synchronisierte e peek () {// Die aktuelle Anzahl der Containerelemente int len = size (); // Wenn es kein Element gibt, werfen Sie eine Ausnahme direkt aus, wenn (len == 0) neue leere Stackexception () werfen; // Aufrufelementat -Methode zum Abrufen des letzten Elements des Arrays (das letzte Element befindet sich oben im Stapel) returnelementat (len - 1); } / *** das Element an dieser Position gemäß dem Indexindex abrufen. Diese Methode befindet sich im Vektor* / public synchronisierte E -Elementat (int Index) {// Beenden Sie die Grenzen if (index> = elementCount) {throw New ArrayIndexoutOfBoundSexception (index + "> =" + elementCount); } // das Element return (e) elementData [index]; }2.Pop () - Stapeln Sie den Stapel (aus dem Stapel), holen Sie das Objekt oben am Stapel und löschen Sie das Objekt aus dem Container
/ *** Bummeln Sie den Stapel, holen Sie sich das Objekt oben im Stapel*/ public synchronisierte e pop () {// Notieren Sie das Objekt oben im Stapel e obj; // die aktuelle Anzahl der Containerelemente int len = size (); // das Objekt über Peek () -Methode obj = peek () oben im Stapel obj beziehen; // Rufen Sie die Entfernungsmethode auf, um das Objekt oben im Stackelementat (Len - 1) zu löschen. // kehre zum Objekt oben in der Stapelrendite zurück; } / *** Löschen Sie das Element gemäß dem Indexindex* / public synchronisierte void RemovalElementat (int Index) {modcount ++; // Grenzen beenden if (index> = elementCount) {throw New ArrayIndexoutOfBoundSexception (index + "> =" + elementCount); } else if (index <0) {throw New ArrayIndexoutOfBoundSexception (Index); } // Berechnen Sie die Anzahl der Array -Elemente, die bewegt werden sollen. Wenn (j> 0) {// das Array verschieben, löschen Sie eine in der Mitte, bewegen Sie also das nachfolgende Element -Vorwärts -Vorwärts -System (hier bewegt sich hier direkt das Indexpositionselement, das dem Löschen des Löschens entspricht). ArrayCopy (ElementData, Index + 1, ElementData, Index, J); } // minus 1 elementCount--; // Setzen Sie das letzte Element des Containers auf leer (weil ein Element gelöscht wurde und die Elemente hinter dem Index vorwärts gebracht wurden, sodass das letzte nutzlos war) elementData [elementCount] = null; / * Um GC seine Arbeit zu erledigen */}3.push (e item) - drücken (in den Stapel), fügen Sie das Objekt in den Container hinzu und geben Sie es zurück
/ ** * fügen Sie das Objekt in den Container hinzu und geben Sie zurück */ public e push (e item) {// addElement to addElement (item); // Rückgabe des Element -Rückgabeelements; } /*** Fügen Sie das Element in den Container hinzu. Diese Methode befindet sich im Vektor*/ public synchronisierte Hohlraum -Addelement (e obj) {modcount ++; // Vergrößerungsprüfung tealEcapacityHelper (elementCount + 1); // das Objekt in das Array einfügen, die Anzahl der Elemente +1 elementData [elementCount ++] = obj; }4.Search (Objekt O) - Gibt die Position des Objekts im Container zurück. Die Oberseite des Stapels beträgt 1
/ ** * Gibt die Position des Objekts im Container zurück, die Oberseite des Stapels ist 1 */ öffentliches synchronisiertes Int -Such (Objekt o) {// Finden Sie das Element aus dem Array aus dem letzten Auftreten von int i = lastIndexof (o); // Weil die Oberseite des Stapels 1 zählt 1, müssen Sie Size () - I verwenden, um zu berechnen, ob (i> = 0) {return size () - i; } return -1; }5.Ampty () - ist der Behälter leer
/ *** Überprüfen Sie, ob der Container leer ist*/ public boolean leer () {return size () == 0; }Unterabschnitt:
Zu diesem Zeitpunkt wird die Stack -Methode analysiert. Da Stack letztendlich auf Arrays basiert, ist es immer noch leicht zu verstehen (da er auf ArrayList basiert).
Obwohl der Quellcode von Stack in JDK analysiert wurde, muss er hier erörtert werden. Ich weiß nicht, ob ich festgestellt habe, dass der Stack hier sehr seltsam ist.
(1) Warum wird Stack basierend auf Arrays implementiert?
Wir alle kennen die Eigenschaften von Arrays: Sie sind für die Abfragung basierend auf Einweisen (Zufallszugriff) bequem, aber der Speicher ist festgelegt und die Effizienz der Kapazitätserweiterung ist gering. Es ist leicht, sich das am besten geeignete Ding für Stack vorzustellen, um verknüpfte Listen zu verwenden.
(2) Warum erbt Stack Vektor?
Vererbung bedeutet, dass Stack die Vektormethode erbt, wodurch sich Stack etwas unangemessen anfühlt, sowohl eine Liste als auch ein Stack. Was sollte ein vernünftiger Ansatz sein, wenn Sie den Vektor erben müssen: Stack erben keinen Vektor, sondern hat nur einen Hinweis auf den Vektor selbst, ist die Aggregation richtig?
Die einzige Erklärung ist, dass Stack von JDK1.0 erstellt wurde. Zu diesem Zeitpunkt hatten die Container in JDK nicht nur Vektoren wie ArrayList, LinkedList usw., und da sie bereits Vektor haben und Stapelfunktionen implementieren können, dann tun Sie dies. . . Da es ideal ist, Stack mit verknüpften Listen zu implementieren, versuchen wir es:
import Java.util.linkedList; öffentliche Klasse LinkedStack <E> {private linkedList <E> verlinkt; public linkedStack () {this.linked = new LinkedList <E> (); } public e push (e item) {this.linked .addfirst (item); Gegenstand zurückgeben; } public e pop () {if (this.linked.isempty ()) {return null; } return this.linked.removeFirst (); } public e peek () {if (this.linked.isempty ()) {return null; } return this.linked.getFirst (); } public int Search (e item) {int i = this.linked.indexof (item); Return i + 1; } public boolean leer () {return this.linked.isempty (); }}Der von LinkedList implementierte Stack wird hier verwendet. Denken Sie daran, wie in LinkedList erwähnt, linkedList implementiert die Deque -Schnittstelle, sodass sie als Stapel (zuerst ein- und aus) und als Warteschlange (zuerst ein- und aus) verwendet werden kann.
4. Die Differenz zwischen Vector & ArrayList
In der List -Schnittstelle befinden sich drei Implementierungsklassen, nämlich ArrayList, Vector und LinkedList. Die Liste wird zum Speichern mehrerer Elemente verwendet, kann die Reihenfolge der Elemente beibehalten und die Wiederholung von Elementen ermöglicht.
Die relevanten Unterschiede zwischen den drei spezifischen Implementierungsklassen sind wie folgt:
1. ArrayList ist die am häufigsten verwendete List -Implementierungsklasse, die intern über Arrays implementiert wird und die schnelle Zufallszugriff auf Elemente ermöglicht. Der Nachteil von Arrays ist, dass zwischen jedem Element nicht verteilt werden kann. Wenn die Arraygröße nicht erfüllt ist, muss die Speicherkapazität erhöht werden. Es ist notwendig zu sagen, dass die Daten des bereits Array in den neuen Speicherplatz kopiert werden. Beim Einsetzen oder Löschen von Elementen aus der mittleren Position der ArrayList muss das Array kopiert, bewegt werden und die Kosten sind relativ hoch. Daher eignet es sich für zufällige Lookups und Traversals, nicht für Einfügen und Löschen.
2. Der Vektor wird auch durch Arrays implementiert. Der Unterschied besteht darin, dass er die Threadsynchronisation unterstützt, dh zu einem bestimmten Zeitpunkt kann nur ein Thread einen Vektor schreiben, um Inkonsistenz zu vermeiden, die durch mehrere Threads gleichzeitig verursacht werden, aber es kostet viel, die Synchronisation zu implementieren. Der Zugriff auf sie ist also langsamer als der Zugriff auf ArrayList.
3. LinkedList verwendet eine verknüpfte Listenstruktur, um Daten zu speichern, die für dynamische Einfügung und Löschung von Daten sehr geeignet sind, und die Zufallszugriffs- und Durchlaufgeschwindigkeiten sind relativ langsam. Darüber hinaus enthält es auch Methoden, die nicht in der List -Schnittstelle definiert sind, die speziell zum Betrieb von Tabellenheader- und Schwanzelementen verwendet werden und als Stapel, Warteschlangen und bidirektionale Warteschlangen verwendet werden können.
5. Ein kurzes Verständnis der Warteschlange, zweifristiger Warteschlange Deque
1. Warteschlange
Java5 wurde eine neue Java.util.queue -Schnittstelle hinzugefügt, um gemeinsame Warteschlangenvorgänge zu unterstützen. Diese Schnittstelle erweitert die Schnittstelle von Java.util.Collection.
Öffentliche Schnittstelle Warteschlange <E> Erweitert die Sammlung <e>
Zusätzlich zu den grundlegenden Sammlungsvorgängen bieten Warteschlangen andere Einfügen, Extrakt- und Überprüfungsvorgänge.
Jede Methode hat zwei Formulare: eine Ausnahme aus (wenn eine Operation fehlschlägt), und der andere gibt einen besonderen Wert zurück (null oder false, abhängig von der Operation).
Warteschlangen sortieren normalerweise (aber nicht unbedingt) einzelne Elemente in einem FIFO (zuerst zuerst). Die vorrangige Warteschlange und die LIFO -Warteschlange (oder Stapel) sind jedoch Ausnahmen. Ersteres sortiert die Elemente nach der natürlichen Reihenfolge des bereitgestellten Komparators oder der Elemente, und letzteres sortiert die Elemente in LIFO (neuestes in erster Stelle).
In der FIFO -Warteschlange werden alle neuen Elemente am Ende der Warteschlange eingefügt, und das Entfernungselement wird aus dem Warteschlangenheader entfernt.
Versuchen Sie bei Verwendung der Warteschlange, die Methoden zur Sammlung von Add () und REME () zu vermeiden. Verwenden Sie jedoch Offer () zum Hinzufügen von Elementen und verwenden Sie Poll (), um Elemente zu erhalten und zu entfernen. Ihr Vorteil ist, dass sie feststellen können, ob der Erfolg durch Rückgabe des Wertes erzielt wird, und die Methoden add () und remy () werden Ausnahmen auswirken, wenn sie ausfallen. Wenn Sie das vordere Ende verwenden möchten, ohne das Element zu entfernen, verwenden Sie die Methode Element () oder peek ().
Die Angebotsmethode kann ein Element einfügen, andernfalls gibt es false zurück. Dies unterscheidet sich von der Methode für die Sammlung.ADD, die nur nicht Elemente hinzufügen kann, indem sie eine ungeprüfte Ausnahme ausgelegt hat.
Die Methoden REME () und POLL () werden den Header der Warteschlange entfernen und zurückgeben. Welches Element aus der Warteschlange entfernt wird, ist die Funktion der Warteschlangesortierrichtlinie, die in verschiedenen Implementierungen unterschiedlich ist. Die Methoden von REME () und POLL () verhalten sich nur dann anders, wenn die Warteschlange leer ist: Die Methode von REME () () bringt eine Ausnahme aus, während die Poll () -Methode null zurückgibt.
Element () und peek () kehren zurück, entfernen Sie aber den Warteschlangenkopf, aber nicht entfernen.
Warteschlangenimplementierungen ermöglichen im Allgemeinen keine Insertion von Nullelementen, obwohl einige Implementierungen (z. B. LinkedList) die Insertion von Nulls nicht verbieten. Selbst in Implementierungen, die Null zulassen, sollte Null nicht in die Warteschlange eingefügt werden, da Null auch als Sonderrückgabewert für die Umfragemethode verwendet wird, was darauf hinweist, dass die Warteschlange keine Elemente enthält.
Es ist erwähnenswert, dass die LinkedList -Klasse die Warteschlangenschnittstelle implementiert, sodass wir LinkedList als Warteschlange verwenden können.
import Java.util.queue; import Java.util.linkedList; public class testqueue {public static void main (String [] args) {queue <string> queue = new LinkedList <string> (); queue.offer ("Hallo"); queue.offer ("Welt!"); queue.offer ("Hallo!"); System.out.println (queue.size ()); String str; while ((str = queue.poll ())! = null) {System.out.print (str); } System.out.println (); System.out.println (queue.size ()); }}2. Deque
öffentliche Schnittstelle Deque <e> erweitert Warteschlange <e>
Eine lineare Sammlung, die das Einsetzen und Entfernen von Elementen an beiden Enden unterstützt.
Der Name Deque ist die Abkürzung der "Doppel -Ende -Warteschlange" und wird normalerweise als "Deck" gelesen.
Die meisten Deque-Implementierungen haben keine feste Grenze für die Anzahl der Elemente, die sie enthalten können, aber diese Schnittstelle unterstützt sowohl Kapazitätsbegrenzungen als auch zweigeschädigte Warteschlangen ohne feste Größengrenzen.
Diese Schnittstelle definiert eine Methode zum Zugriff auf Elemente an beiden Enden einer doppelten Warteschlange. Bietet Methoden zum Einfügen, Entfernen und Überprüfen von Elementen. Da diese Schnittstelle die Warteschlangenschnittstellenwarteschlange erbt, gibt es für jede ihrer Methoden zwei Formen: Eine Ausnahme bringt eine Ausnahme aus, wenn der Vorgang fehlschlägt, und der andere gibt einen speziellen Wert zurück (null oder false, abhängig von der Operation).
A. Wenn Sie eine Doppel-Warteschlange als Warteschlange verwenden, erhalten Sie ein FIFO-Verhalten (erstes, erstes, erster). Fügen Sie ein Element zum Ende der doppelten Warteschlange hinzu und entfernen Sie das Element vom Beginn der doppelten Warteschlange. Die von der Warteschlangenschnittstelle geerbten Methoden entsprechen der Deque -Methode vollständig, wie in der folgenden Tabelle gezeigt:
B. Wird als LIFO (Last in First Out) verwendet. Diese Schnittstelle sollte zuerst als Legacy -Stapelklassen verwendet werden. Bei Verwendung einer doppelt geendeten Warteschlange als Stapel wird das Element in den Beginn der Doppel-End-Warteschlange gedrückt und taucht ab Beginn der Doppelte-Warteschlange auf. Die Stack -Methode entspricht der Deque -Methode vollständig, wie in der folgenden Tabelle gezeigt: