java stack tutorial stack class implementation with examples
In diesem Tutorial wird anhand von Beispielen erläutert, was Stack in Java ist, Java-Stack-Klasse, Stack-API-Methoden, Stack-Implementierung mithilfe von Array und verknüpfter Liste:
Ein Stack ist eine geordnete Datenstruktur, die zum Java Collection Framework gehört. In dieser Sammlung werden die Elemente nur an einem Ende hinzugefügt und entfernt. Das Ende, an dem die Elemente hinzugefügt und entfernt werden, wird als 'Top of the Stack' bezeichnet.
Da das Hinzufügen und Löschen nur an einem Ende erfolgt, ist das erste Element, das dem Stapel hinzugefügt wird, das letzte Element, das vom Stapel entfernt wurde. Daher wird der Stapel als LIFO-Datenstruktur (Last-In, First-Out) bezeichnet.
=> Schauen Sie sich hier den Java Beginners Guide an
Was du lernen wirst:
- Java Stack Collection
- Fazit
Java Stack Collection
Eine bildliche Darstellung des Stapels ist unten angegeben.
Wie in der obigen Darstellungssequenz gezeigt, ist der Stapel anfangs leer und die Oberseite des Stapels wird auf -1 gesetzt. Dann starten wir eine Push-Operation, mit der dem Stapel ein Element hinzugefügt wird.
In der zweiten Darstellung drücken wir also Element 10. An diesem Punkt wird die Oberseite inkrementiert. Wir schieben das Element 20 erneut in den Stapel, wodurch die Oberseite weiter erhöht wird.
In der letzten Darstellung starten wir eine Pop-Operation. Diese Operation wird verwendet, um ein Element vom Stapel zu entfernen. Ein Element, das derzeit auf 'Oben' zeigt, wird durch die Pop-Operation entfernt.
Eine Stapeldatenstruktur unterstützt die folgenden Operationen:
- Drücken: Fügt dem Stapel ein Element hinzu. Infolgedessen wird der Wert der Oberseite erhöht.
- Pop: Ein Element wird vom Stapel entfernt. Nach der Pop-Operation wird der Wert von top dekrementiert.
- Spähen: Diese Operation wird verwendet, um nach einem Element zu suchen. Der Wert von top wird nicht geändert.
Die Oberseite des Stapels, die als Ende zum Hinzufügen / Entfernen von Elementen zum Stapel verwendet wird, kann zu einem bestimmten Zeitpunkt auch verschiedene Werte haben. Wenn die Größe des Stapels N ist, hat die Oberseite des Stapels die folgenden Werte unter verschiedenen Bedingungen, je nachdem, in welchem Zustand sich der Stapel befindet.
| Status des Stapels | Top Wert |
|---|---|
| Stapel leer | -1 |
| Ein Element im Stapel | 0 |
| Stapel voll | N-1 |
| Überlauf (Elemente> N) | N. |
Stapelklasse in Java
Java Collection Framework bietet eine Klasse mit dem Namen 'Stack'. Diese Stack-Klasse erweitert die Vector-Klasse und implementiert die Funktionalität der Stack-Datenstruktur.
Das folgende Diagramm zeigt die Hierarchie der Stack-Klasse.
Wie im obigen Diagramm gezeigt, erbt die Stack-Klasse die Vector-Klasse, die wiederum die List Interface of Collection-Schnittstelle implementiert.
Die Stack-Klasse ist Teil des Pakets java.util. Um die Stack-Klasse in das Programm aufzunehmen, können Sie die import-Anweisung wie folgt verwenden.
import java.util.*; oder
import java.util.Stack; Erstellen Sie einen Stapel in Java
Sobald wir die Stack-Klasse importiert haben, können wir ein Stack-Objekt wie folgt erstellen:
Stack mystack = new Stack(); Wir können auch einen generischen Typ eines Stapelklassenobjekts wie folgt erstellen:
Stack myStack = new Stack; Hier kann data_type ein beliebiger gültiger Datentyp in Java sein.
Zum Beispiel ,Wir können die folgenden Stack-Klassenobjekte erstellen.
Stack stack_obj = new Stack(); Stack str_stack = new Stack(); Stapel-API-Methoden in Java
Die Stack-Klasse bietet Methoden zum Hinzufügen, Entfernen und Suchen von Daten im Stack. Es bietet auch eine Methode, um zu überprüfen, ob der Stapel leer ist. Wir werden diese Methoden im folgenden Abschnitt diskutieren.
Stack-Push-Betrieb
Die Push-Operation wird verwendet, um Elemente in den Stapel zu verschieben oder hinzuzufügen. Sobald wir eine Stapelinstanz erstellt haben, können wir die Push-Operation verwenden, um die Elemente des Stapelobjekttyps zum Stapel hinzuzufügen.
Der folgende Code wird verwendet, um einen Ganzzahlstapel mit den Werten zu initialisieren.
Stack myStack = new Stack(); myStack.push(10); myStack.push(15); myStack.push(20); Der anfängliche Stapel, der als Ergebnis der obigen Codeausführung erhalten wird, ist unten gezeigt:
Wenn wir eine weitere push () - Operation wie unten gezeigt ausführen,
push(25); Der resultierende Stapel ist:
Stack Pop Operation
Wir können das Element mit der Operation 'pop' vom Stapel entfernen. Das Element, auf das die Oberseite derzeit zeigt, wird vom Stapel entfernt.
Der folgende Code erreicht dies.
Stack intStack = new Stack(); intStack.push(100); intStack.push(200); int val = intStack.pop(); Die Variable val enthält den Wert 200, da dies das letzte Element war, das in den Stapel verschoben wurde.
Die Stapeldarstellung für Push- und Pop-Operationen lautet wie folgt:
Stack Peek Operation
Die Peek-Operation gibt die Oberseite des Stapels zurück, ohne das Element zu entfernen. Im obigen Stapelbeispiel gibt 'intStack.peek ()' 200 zurück.
Stack isEmpty Operation
Die isEmpty () -Operation der Stack-Klasse prüft, ob das Stack-Objekt leer ist. Es gibt true zurück, wenn der Stack keine Elemente enthält, andernfalls false.
Stapelsuchoperation
Mit der Operation search () können wir nach einem Element auf dem Stapel suchen. Die search () -Operation gibt den Index des gesuchten Elements zurück. Dieser Index wird vom oberen Rand des Stapels gezählt.
Stack intStack = new Stack (); intStack.push (100); intStack.push (200); int index = inStack.search(100); //index will have the value 2.Stapelgrösse
Die Größe des Stack-Objekts wird durch das angegeben java.util.Stack.size () Methode. Es gibt die Gesamtzahl der Elemente im Stapel zurück.
Im folgenden Beispiel wird die Stapelgröße gedruckt.
Stack myStack = new Stack(); myStack.push(100); myStack.push(200); myStack.push(300); System.out.println('Stack size:' + myStack.size()); //Stack size: 3 Stapelelemente drucken / iterieren
Wir können einen Iterator für den Stapel deklarieren und dann mit diesem Iterator den gesamten Stapel durchlaufen. Auf diese Weise können wir jedes Stapelelement einzeln besuchen und drucken.
Das folgende Programm zeigt, wie Stack mit einem Iterator iteriert werden kann.
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements:'); //get an iterator for the stack Iterator iterator = stack.iterator(); //traverse the stack using iterator in a loop and print each element while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } }Ausgabe:
Stapelelemente:
PUNE MUMBAI NASHIK
antivirus mit VPN kostenlos
Stapeln mit Java 8
Wir können die Stapelelemente auch mit Java 8-Funktionen wie Stream-APIs, forEach- und forEachRemaining-Konstrukten drucken oder durchlaufen.
Das folgende Programm demonstriert die Verwendung von Java 8-Konstrukten zum Durchlaufen des Stapels.
import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements using Java 8 forEach:'); //get a stream for the stack Stream stream = stack.stream(); //traverse though each stream object using forEach construct of Java 8 stream.forEach((element) -> { System.out.print(element + ' '); // print element }); System.out.println('
Stack elements using Java 8 forEachRemaining:'); //define an iterator for the stack Iterator stackIterator = stack.iterator(); //use forEachRemaining construct to print each stack element stackIterator.forEachRemaining(val -> { System.out.print(val + ' '); }); } } Ausgabe:
Stapeln von Elementen mit Java 8 forEach:
PUNE MUMBAI NASHIK
Stapelelemente mit Java 8 forEachRemaining:
PUNE MUMBAI NASHIK
Stapelimplementierung in Java
Das folgende Programm implementiert den detaillierten Stapel, der die verschiedenen Stapeloperationen demonstriert.
import java.util.Stack; public class Main { public static void main(String a()){ //declare a stack object Stack stack = new Stack(); //print initial stack System.out.println('Initial stack : ' + stack); //isEmpty () System.out.println('Is stack Empty? : ' + stack.isEmpty()); //push () operation stack.push(10); stack.push(20); stack.push(30); stack.push(40); //print non-empty stack System.out.println('Stack after push operation: ' + stack); //pop () operation System.out.println('Element popped out:' + stack.pop()); System.out.println('Stack after Pop Operation : ' + stack); //search () operation System.out.println('Element 10 found at position: ' + stack.search(10)); System.out.println('Is Stack empty? : ' + stack.isEmpty()); } } Ausgabe:
Anfangsstapel: ()
Ist der Stapel leer? : wahr
Stapel nach Push-Vorgang: (10, 20, 30, 40)
Element sprang heraus: 40
Stapel nach Pop-Operation: (10, 20, 30)
Element 10 an Position gefunden: 3
Ist der Stapel leer? : falsch
Stapel zum Array in Java
Die Stack-Datenstruktur kann mithilfe der toArray () -Methode der Stack-Klasse in ein Array konvertiert werden.
Das folgende Programm demonstriert diese Konvertierung.
import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); //print the stack System.out.println('The Stack contents: ' + stack); // Create the array and use toArray() method to convert stack to array Object() strArray = stack.toArray(); //print the array System.out.println('The Array contents:'); for (int j = 0; j Ausgabe:
Der Stapelinhalt: (PUNE, MUMBAI, NASHIK)
Der Array-Inhalt:
PUNE MUMBAI NASHIK
Stapelimplementierung in Java mit Array
Der Stack kann mithilfe eines Arrays implementiert werden. Alle Stapeloperationen werden unter Verwendung eines Arrays ausgeführt.
Das folgende Programm demonstriert die Stack-Implementierung mithilfe eines Arrays.
import java.util.*; //Stack class class Stack { int top; //define top of stack int maxsize = 5; //max size of the stack int() stack_arry = new int(maxsize); //define array that will hold stack elements Stack(){ //stack constructor; initially top = -1 top = -1; } boolean isEmpty(){ //isEmpty () method return (top <0); } boolean push (int val){ //push () method if(top == maxsize-1) { System.out.println('Stack Overflow !!'); return false; } else { top++; stack_arry(top)=val; return true; } } boolean pop () { //pop () method if (top == -1) { System.out.println('Stack Underflow !!'); return false; } else { System.out.println('
Item popped: ' + stack_arry(top--)); return true; } } void display () { //print the stack elements System.out.println('Printing stack elements .....'); for(int i = top; i>=0;i--) { System.out.print(stack_arry(i) + ' '); } } } public class Main { public static void main(String() args) { //define a stack object Stack stck = new Stack(); System.out.println('Initial Stack Empty : ' + stck.isEmpty()); //push elements stck.push(10); stck.push(20); stck.push(30); stck.push(40); System.out.println('After Push Operation...'); //print the elements stck.display(); //pop two elements from stack stck.pop(); stck.pop(); System.out.println('After Pop Operation...'); //print the stack again stck.display(); } } Ausgabe:
Anfangsstapel leer: wahr
Nach dem Push-Betrieb…
Stapelelemente drucken… ..
40 30 20 10
Gegenstand geknallt: 40
Gegenstand geknallt: 30
Nach der Pop-Operation…
Stapelelemente drucken… ..
20 10
Stapelimplementierung mit verknüpfter Liste
Der Stack kann auch mithilfe einer verknüpften Liste implementiert werden, genau wie wir es mit Arrays getan haben. Ein Vorteil der Verwendung einer verknüpften Liste zum Implementieren des Stapels besteht darin, dass sie dynamisch wachsen oder schrumpfen kann. Wir brauchen keine maximale Größenbeschränkung wie in Arrays.
Das folgende Programm implementiert eine verknüpfte Liste, um Stapeloperationen auszuführen.
import static java.lang.System.exit; // Stack class using LinkedList class Stack_Linkedlist { // Define Node of LinkedList private class Node { int data; // node data Node nlink; // Node link } // top of the stack Node top; // stack class Constructor Stack_Linkedlist() { this.top = null; } // push () operation public void push(int val) { // create a new node Node temp = new Node(); // checks if the stack is full if (temp == null) { System.out.print('
Stack Overflow'); return; } // assign val to node temp.data = val; // set top of the stack to node link temp.nlink = top; // update top top = temp; } // isEmpty () operation public boolean isEmpty() { return top == null; } // peek () operation public int peek() { // check if the stack is empty if (!isEmpty()) { return top.data; } else { System.out.println('Stack is empty!'); return -1; } } // pop () operation public void pop() { // check if stack is out of elements if (top == null) { System.out.print('
Stack Underflow!!'); return; } // set top to point to next node top = (top).nlink; } //print stack contents public void display() { // check for stack underflow if (top == null) { System.out.printf('
Stack Underflow!!'); exit(1); } else { Node temp = top; System.out.println('Stack elements:'); while (temp != null) { // print node data System.out.print(temp.data + '->'); // assign temp link to temp temp = temp.nlink; } } } } public class Main { public static void main(String() args) { // Create a stack class object Stack_Linkedlist stack_obj = new Stack_Linkedlist(); // push values into the stack stack_obj.push(9); stack_obj.push(7); stack_obj.push(5); stack_obj.push(3); stack_obj.push(1); // print Stack elements stack_obj.display(); // print current stack top System.out.println('
Stack top : ' + stack_obj.peek()); // Pop elements twice System.out.println('Pop two elements'); stack_obj.pop(); stack_obj.pop(); // print Stack elements stack_obj.display(); // print new stack top System.out.println('
New Stack top:' + stack_obj.peek()); } } Ausgabe:
Stapelelemente:
1-> 3-> 5-> 7-> 9->
Stapeloberseite: 1
Pop zwei Elemente
Stapelelemente:
5-> 7-> 9->
Neues Stapeloberteil: 5
Häufig gestellte Fragen
F # 1) Was sind Stacks in Java?
Antworten: Ein Stapel ist eine LIFO-Datenstruktur (Last in, First out) zum Speichern von Elementen. Die Stapelelemente werden an einem Ende, das als Oberseite des Stapels bezeichnet wird, zum Stapel hinzugefügt oder daraus entfernt.
Das Hinzufügen eines Elements zum Stapel erfolgt über die Push-Operation. Das Löschen von Elementen erfolgt über die Pop-Operation. In Java wird ein Stack mithilfe der Stack-Klasse implementiert.
F # 2) Ist Stack eine Sammlung in Java?
Antworten: Ja. Der Stack ist eine Legacy-Sammlung in Java, die ab Java 1.0 über die Sammlungs-API verfügbar ist. Stack erbt die Vektorklasse der List-Schnittstelle.
F # 3) Ist Stack eine Schnittstelle?
Antworten: Der Schnittstellenstapel ist eine Schnittstelle, die die Last-In- und First-Out-Struktur beschreibt und zum Speichern des Status rekursiver Probleme verwendet wird.
F # 4) Wofür werden Stapel verwendet?
Antwort: Im Folgenden sind die Hauptanwendungen des Stapels aufgeführt:
- Auswertung und Konvertierung von Ausdrücken: Der Stapel wird zum Konvertieren von Ausdrücken in Postfix, Infix und Präfix verwendet. Es wird auch verwendet, um diese Ausdrücke auszuwerten.
- Der Stack wird auch zum Parsen von Syntaxbäumen verwendet.
- Der Stapel wird verwendet, um Klammern in einem Ausdruck zu überprüfen.
- Der Stack wird zum Lösen von Backtracking-Problemen verwendet.
- Funktionsaufrufe werden mit Stacks ausgewertet.
F # 5) Was sind die Vorteile des Stapels?
Antworten: Auf dem Stapel gespeicherte Variablen werden bei der Rückgabe automatisch zerstört. Stapel sind eine bessere Wahl, wenn Speicher zugewiesen und freigegeben wird. Stapel bereinigen auch den Speicher. Abgesehen davon können Stapel effektiv verwendet werden, um Ausdrücke auszuwerten und die Ausdrücke zu analysieren.
Fazit
Damit ist unser Tutorial zu Stacks in Java abgeschlossen. Die Stapelklasse ist Teil der Sammlungs-API und unterstützt Push-, Pop-, Peek- und Suchvorgänge. Die Elemente werden nur an einem Ende zum Stapel hinzugefügt oder daraus entfernt. Dieses Ende wird als Oberseite des Stapels bezeichnet.
In diesem Tutorial haben wir alle von der Stack-Klasse unterstützten Methoden gesehen. Wir haben den Stack auch mithilfe von Arrays und verknüpften Listen implementiert.
Wir werden in unseren nachfolgenden Tutorials mit anderen Sammlungsklassen fortfahren.
=> Lesen Sie die Easy Java Training Series durch
Literatur-Empfehlungen
- Java Reflection Tutorial mit Beispielen
- Java Scanner Class Tutorial mit Beispielen
- Was ist eine Java-HashTable? HashTable-Implementierung und Beispiel
- Was ist Java Vector? Java Vector Class Tutorial mit Beispielen
- Java Array Class Tutorial - java.util.Arrays-Klasse mit Beispielen
- Java-Grundlagen: Java-Syntax, Java-Klasse und Java-Kernkonzepte
- LinkedHashMap In Java - LinkedHashMap Beispiel & Implementierung
- Java SWING Tutorial: Container-, Komponenten- und Ereignisbehandlung
