Java Sammlungsrahmen stellt eine Stack-Klasse bereit, die a modelliert und implementiert Das folgende Diagramm zeigt die Hierarchie der Stack-Klasse :
Die Klasse unterstützt einen Standardkonstruktor Stapel() was man gewohnt ist Erstellen Sie einen leeren Stapel .
Erklärung:
public class Stack extends Vector>
Alle implementierten Schnittstellen:
- Serialisierbar: Es handelt sich um eine Markierungsschnittstelle, die Klassen implementieren müssen, wenn sie serialisiert und deserialisiert werden sollen.
- Klonbar: Dies ist eine Schnittstelle in Java, die von einer Klasse implementiert werden muss, damit ihre Objekte geklont werden können.
- Wiederholbar: Diese Schnittstelle stellt eine Sammlung von Objekten dar, die iterierbar sind – also iterierbar sind.
- Sammlung: Eine Sammlung stellt eine Gruppe von Objekten dar, die als ihre Elemente bezeichnet werden. Die Collection-Schnittstelle wird verwendet, um Sammlungen von Objekten weiterzugeben, bei denen maximale Allgemeingültigkeit gewünscht wird.
- Aufführen: Die List-Schnittstelle bietet eine Möglichkeit, die geordnete Sammlung zu speichern. Es ist eine untergeordnete Schnittstelle von Collection.
- RandomAccess: Dies ist eine Markierungsschnittstelle, die von List-Implementierungen verwendet wird, um anzuzeigen, dass sie schnellen (im Allgemeinen zeitkonstanten) Direktzugriff unterstützen.
Wie erstelle ich einen Stapel?
Um einen Stapel zu erstellen, müssen wir importieren java.util.stack Paket und verwenden Sie den Stack()-Konstruktor dieser Klasse. Das folgende Beispiel erstellt einen leeren Stapel.
Stapelstapel = neuer Stapel();
Hier ist E der Objekttyp.
Beispiel:
Java
// Java code for stack implementation> import> java.io.*;> import> java.util.*;> class> Test> {> >// Pushing element on the top of the stack> >static> void> stack_push(Stack stack)> >{> >for>(>int> i =>0>; i <>5>; i++)> >{> >stack.push(i);> >}> >}> > >// Popping element from the top of the stack> >static> void> stack_pop(Stack stack)> >{> >System.out.println(>'Pop Operation:'>);> >for>(>int> i =>0>; i <>5>; i++)> >{> >Integer y = (Integer) stack.pop();> >System.out.println(y);> >}> >}> >// Displaying element on the top of the stack> >static> void> stack_peek(Stack stack)> >{> >Integer element = (Integer) stack.peek();> >System.out.println(>'Element on stack top: '> + element);> >}> > >// Searching element in the stack> >static> void> stack_search(Stack stack,>int> element)> >{> >Integer pos = (Integer) stack.search(element);> >if>(pos == ->1>)> >System.out.println(>'Element not found'>);> >else> >System.out.println(>'Element is found at position: '> + pos);> >}> >public> static> void> main (String[] args)> >{> >Stack stack =>new> Stack();> >stack_push(stack);> >stack_pop(stack);> >stack_push(stack);> >stack_peek(stack);> >stack_search(stack,>2>);> >stack_search(stack,>6>);> >}> }> |
... in Java
>
>
Ausgabe:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Durchführen verschiedener Operationen an der Stack-Klasse
1. Elemente hinzufügen: Um dem Stapel ein Element hinzuzufügen, können wir verwenden push()-Methode . Das drücken() Platzieren Sie das Element oben im Stapel.
Java
// Java program to add the> // elements in the stack> import> java.io.*;> import> java.util.*;> class> StackDemo {> > >// Main Method> >public> static> void> main(String[] args)> >{> >// Default initialization of Stack> >Stack stack1 =>new> Stack();> >// Initialization of Stack> >// using Generics> >Stack stack2 =>new> Stack();> >// pushing the elements> >stack1.push(>'4'>);> >stack1.push(>'All'>);> >stack1.push(>'Geeks'>);> >stack2.push(>'Geeks'>);> >stack2.push(>'For'>);> >stack2.push(>'Geeks'>);> >// Printing the Stack Elements> >System.out.println(stack1);> >System.out.println(stack2);> >}> }> |
>
>
Ausgabe:
[4, All, Geeks] [Geeks, For, Geeks]>
2. Zugriff auf das Element: Um das erste Element des Stapels oder das oben im Stapel vorhandene Element abzurufen oder abzurufen, können wir verwenden spähen() Methode. Das abgerufene Element wird nicht gelöscht oder aus dem Stapel entfernt.
Java
// Java program to demonstrate the accessing> // of the elements from the stack> import> java.util.*;> import> java.io.*;> public> class> StackDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating an empty Stack> >Stack stack =>new> Stack();> >// Use push() to add elements into the Stack> >stack.push(>'Welcome'>);> >stack.push(>'To'>);> >stack.push(>'Geeks'>);> >stack.push(>'For'>);> >stack.push(>'Geeks'>);> >// Displaying the Stack> >System.out.println(>'Initial Stack: '> + stack);> >// Fetching the element at the head of the Stack> >System.out.println(>'The element at the top of the'> >+>' stack is: '> + stack.peek());> >// Displaying the Stack after the Operation> >System.out.println(>'Final Stack: '> + stack);> >}> }> |
verknüpfte Liste Java
>
>
Ausgabe:
Initial Stack: [Welcome, To, Geeks, For, Geeks] The element at the top of the stack is: Geeks Final Stack: [Welcome, To, Geeks, For, Geeks]>
3. Elemente entfernen: Um ein Element aus dem Stapel zu entfernen, können wir verwenden Pop() Methode. Das Element wird von der Oberseite des Stapels abgehoben und von diesem entfernt.
Java
// Java program to demonstrate the removing> // of the elements from the stack> import> java.util.*;> import> java.io.*;> public> class> StackDemo {> >public> static> void> main(String args[])> >{> >// Creating an empty Stack> >Stack stack =>new> Stack();> >// Use add() method to add elements> >stack.push(>10>);> >stack.push(>15>);> >stack.push(>30>);> >stack.push(>20>);> >stack.push(>5>);> >// Displaying the Stack> >System.out.println(>'Initial Stack: '> + stack);> >// Removing elements using pop() method> >System.out.println(>'Popped element: '> >+ stack.pop());> >System.out.println(>'Popped element: '> >+ stack.pop());> >// Displaying the Stack after pop operation> >System.out.println(>'Stack after pop operation '> >+ stack);> >}> }> |
>
>
Ausgabe:
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30]>
Beispiel
In Java ist die Stack-Klasse eine Unterklasse der Vector-Klasse und stellt einen Last-in-First-out (LIFO)-Stapel von Objekten dar. Es erweitert die Vector-Klasse, um eine einfache Implementierung der Stack-Datenstruktur zu ermöglichen.
Hier ist ein Beispiel dafür, wie Sie die Stack-Klasse in Java verwenden können:
Java
import> java.util.Stack;> public> class> StackExample {> >public> static> void> main(String[] args) {> >// Create a new stack> >Stack stack =>new> Stack();> >// Push elements onto the stack> >stack.push(>1>);> >stack.push(>2>);> >stack.push(>3>);> >stack.push(>4>);> >// Pop elements from the stack> >while>(!stack.isEmpty()) {> >System.out.println(stack.pop());> >}> >}> }> |
>
>Ausgabe
4 3 2 1>
In diesem Beispiel importieren wir zunächst die Stack-Klasse aus dem Paket java.util. Anschließend erstellen wir mit dem Standardkonstruktor ein neues Stack-Objekt namens stack. Mit der Methode push() legen wir vier ganze Zahlen auf den Stapel. Anschließend entfernen wir die Elemente mithilfe der Methode pop() innerhalb einer While-Schleife vom Stapel. Die Methode isEmpty() wird verwendet, um zu prüfen, ob der Stapel leer ist, bevor versucht wird, ein Element zu entfernen.
Dieser Code erstellt einen Stapel von Ganzzahlen und schiebt 4 Ganzzahlen in der Reihenfolge 1 -> 2 -> 3 -> 4 auf den Stapel. Anschließend entfernen wir Elemente nacheinander aus dem Stapel, indem wir die Methode pop() verwenden, die die entfernt und zurückgibt oberstes Element des Stapels. Da der Stapel einer LIFO-Reihenfolge (Last-In-First-Out) folgt, werden die Elemente in der umgekehrten Reihenfolge des Einfügens eingefügt, was zu der oben gezeigten Ausgabe führt.
Die Stack-Klasse bietet mehrere andere Methoden zum Manipulieren des Stapels, z. B. peek() zum Abrufen des obersten Elements, ohne es zu entfernen, search() zum Suchen nach einem Element im Stapel und Zurückgeben seiner Position und size() zum Zurückgeben der aktuellen Größe des Stapels. Die Stack-Klasse bietet außerdem mehrere Konstruktoren zum Erstellen eines Stapels mit einer angegebenen Anfangskapazität oder durch Kopieren eines vorhandenen Stapels.
Methoden in der Stack-Klasse
| METHODE | BESCHREIBUNG |
|---|---|
| leer() | Es gibt true zurück, wenn sich nichts oben auf dem Stapel befindet. Andernfalls wird false zurückgegeben. |
| spähen() | Gibt das Element oben im Stapel zurück, entfernt es jedoch nicht. |
| Pop() | Entfernt das oberste Element des Stapels und gibt es zurück. Eine „EmptyStackException“ Eine Ausnahme wird ausgelöst, wenn wir pop() aufrufen, während der aufrufende Stapel leer ist. |
| push(Objektelement) | Schiebt ein Element oben auf den Stapel. |
| Suche (Objektelement) for-Schleife Java | Es bestimmt, ob ein Objekt im Stapel vorhanden ist. Wenn das Element gefunden wird, Es gibt die Position des Elements von der Oberseite des Stapels zurück. Andernfalls wird -1 zurückgegeben. |
Von der Klasse java.util.Vector geerbte Methoden
| METHODE | BESCHREIBUNG |
|---|---|
| add(Objekt obj) | Hängt das angegebene Element an das Ende dieses Vektors an. |
| add(int index, Object obj) | Fügt das angegebene Element an der angegebenen Position in diesem Vektor ein. |
| addAll(Sammlung c) | Hängt alle Elemente in der angegebenen Sammlung an das Ende dieses Vektors an. in der Reihenfolge, in der sie vom Iterator der angegebenen Sammlung zurückgegeben werden. |
| addAll(int index, Collection c) | Fügt alle Elemente in der angegebenen Sammlung an der angegebenen Position in diesen Vektor ein. |
| addElement(Objekt o) | Fügt die angegebene Komponente am Ende dieses Vektors hinzu und erhöht seine Größe um eins. |
| Kapazität() | Gibt die aktuelle Kapazität dieses Vektors zurück. |
| klar() | Entfernt alle Elemente aus diesem Vektor. |
| Klon() | Gibt einen Klon dieses Vektors zurück. |
| enthält(Objekt o) | Gibt true zurück, wenn dieser Vektor das angegebene Element enthält. |
| enthältAlle(Sammlung c) | Gibt „true“ zurück, wenn dieser Vektor alle Elemente in der angegebenen Sammlung enthält. |
| copyInto(Object []array) | Kopiert die Komponenten dieses Vektors in das angegebene Array. |
| elementAt(int index) | Gibt die Komponente am angegebenen Index zurück. |
| Elemente() | Gibt eine Aufzählung der Komponenten dieses Vektors zurück. |
| secureCapacity(int minCapacity) | Erhöht bei Bedarf die Kapazität dieses Vektors, um sicherzustellen, dass er halten kann mindestens die Anzahl der Komponenten, die durch das Argument für die Mindestkapazität angegeben wird. |
| gleich() | Vergleicht das angegebene Objekt mit diesem Vektor auf Gleichheit. |
| erstesElement() | Gibt die erste Komponente (das Element bei Index 0) dieses Vektors zurück. |
| get(int index) | Gibt das Element an der angegebenen Position in diesem Vektor zurück. |
| Hash-Code() | Gibt den Hash-Codewert für diesen Vektor zurück. |
| indexOf(Objekt o) | Gibt den Index des ersten Vorkommens des angegebenen Elements in diesem Vektor zurück, oder -1 wenn dieser Vektor das Element nicht enthält. |
| indexOf(Objekt o, int index) | Gibt den Index des ersten Vorkommens des angegebenen Elements in diesem Vektor zurück, wobei vom Index aus vorwärts gesucht wird, oder gibt -1 zurück, wenn das Element nicht gefunden wird. |
| insertElementAt(Object o, int index) | Fügt das angegebene Objekt als Komponente in diesen Vektor am angegebenen Index ein. |
| ist leer() | Testet, ob dieser Vektor keine Komponenten hat. |
| Iterator() | Gibt einen Iterator über die Elemente in dieser Liste in der richtigen Reihenfolge zurück. |
| lastElement() | Gibt die letzte Komponente des Vektors zurück. |
| lastIndexOf(Objekt o) | Gibt den Index des letzten Vorkommens des angegebenen Elements in diesem Vektor zurück, oder -1 Wenn dieser Vektor das Element nicht enthält. |
| lastIndexOf(Object o, int index) | Gibt den Index des letzten Vorkommens des angegebenen Elements in diesem Vektor zurück. Sucht vom Index aus rückwärts oder gibt -1 zurück, wenn das Element nicht gefunden wird. |
| listIterator() | Gibt einen Listeniterator über die Elemente in dieser Liste zurück (in der richtigen Reihenfolge). |
| listIterator(int index) | Gibt einen Listeniterator über die Elemente in dieser Liste zurück (in der richtigen Reihenfolge). beginnend an der angegebenen Position in der Liste. |
| entfernen(int index) | Entfernt das Element an der angegebenen Position in diesem Vektor. |
| entfernen(Objekt o) | Entfernt das erste Vorkommen des angegebenen Elements in diesem Vektor. Wenn der Vektor das Element nicht enthält, bleibt es unverändert. |
| RemoveAll(Sammlung c) | Entfernt aus diesem Vektor alle seine Elemente, die in der angegebenen Sammlung enthalten sind. |
| RemoveAllElements() | Entfernt alle Komponenten aus diesem Vektor und setzt seine Größe auf Null. |
| removeElement(Objekt o) | Entfernt das erste (niedrigstindizierte) Vorkommen des Arguments aus diesem Vektor. |
| removeElementAt(int index) | Löscht die Komponente am angegebenen Index. |
| removeRange(int fromIndex, int toIndex) | Entfernt aus dieser Liste alle Elemente, deren Index zwischen fromIndex (inklusive) und toIndex (exklusiv) liegt. |
| keepAll(Collection c) | Behält nur die Elemente in diesem Vektor, die in der angegebenen Sammlung enthalten sind. |
| set(int index, Object o) | Ersetzt das Element an der angegebenen Position in diesem Vektor durch das angegebene Element. |
| setElementAt(Object o, int index) | Legt die Komponente am angegebenen Index dieses Vektors als angegebenes Objekt fest. |
| setSize(int newSize) | Legt die Größe dieses Vektors fest. |
| Größe() | Gibt die Anzahl der Komponenten in diesem Vektor zurück. |
| subList(int fromIndex, int toIndex) | Gibt eine Ansicht des Teils dieser Liste zwischen fromIndex (inklusive) und toIndex (exklusiv) zurück. |
| toArray() | Gibt ein Array zurück, das alle Elemente in diesem Vektor in der richtigen Reihenfolge enthält. |
| toArray(Object []array) | Gibt ein Array zurück, das alle Elemente in diesem Vektor in der richtigen Reihenfolge enthält; die Laufzeit Der Typ des zurückgegebenen Arrays ist der des angegebenen Arrays. |
| toString() | Gibt eine String-Darstellung dieses Vektors zurück, die die String-Darstellung jedes Elements enthält. |
| trimToSize() | Reduziert die Kapazität dieses Vektors auf die aktuelle Größe des Vektors. |
Priorisieren Sie die Verwendung von Worüber über Stapel -:
Die Stack-Klasse in Java ist eine Legacy-Klasse und erbt von dieser Vektor in Java . Es handelt sich um eine Thread-sichere Klasse und verursacht daher einen Mehraufwand, wenn wir keine Thread-Sicherheit benötigen. Es wird empfohlen, es zu verwenden ArrayDeque für die Stack-Implementierung, da sie in einer Single-Threaded-Umgebung effizienter ist.
Java-Zeichen in Ganzzahl umwandeln
Java
// A Java Program to show implementation> // of Stack using ArrayDeque> import> java.util.*;> class> GFG {> >public> static> void> main (String[] args) {> >Deque stack =>new> ArrayDeque();> >stack.push(>'A'>);> >stack.push(>'B'>);> >System.out.println(stack.peek());> >System.out.println(stack.pop());> >}> }> |
>
>
Ausgabe:
B B>
Ein weiterer Grund, Deque anstelle von Stack zu verwenden, besteht darin, dass Deque die Möglichkeit hat, Streams in Listen umzuwandeln, wobei das LIFO-Konzept beibehalten wird, während Stack dies nicht tut.
Java
import> java.util.*;> import> java.util.stream.Collectors;> class> GFG {> >public> static> void> main (String[] args) {> > >Stack stack =>new> Stack();> >Deque deque =>new> ArrayDeque();> >stack.push(>1>);>//1 is the top> >deque.push(>1>);>//1 is the top> >stack.push(>2>);>//2 is the top> >deque.push(>2>);>//2 is the top> >List list1 = stack.stream().collect(Collectors.toList());>//[1,2]> >System.out.println(>'Using Stack -'>);> >for>(>int> i =>0>; i System.out.print(list1.get(i) + ' ' ); } System.out.println(); List list2 = deque.stream().collect(Collectors.toList());//[2,1] System.out.println('Using Deque -'); for(int i = 0; i System.out.print(list2.get(i) + ' ' ); } System.out.println(); } }> |
>
>Ausgabe
Using Stack - 1 2 Using Deque - 2 1>