Java Stack Klasse: Ein Leitfaden für Anfänger

Einführung

Hallo dort, zukünftige Java-Entwickler! Heute werden wir in die faszinierende Welt der Java Stack Klasse eintauchen. Keine Sorge, wenn du noch nie einen Codezeilen geschrieben hast – ich werde dein freundlicher Guide auf dieser spannenden Reise sein.

Stelle dir vor, du organisiere deine Bücher. Du stelle sie aufeinander, eine über die andere. Das letzte Buch, das du auf den Haufen legst, ist das erste, das du nehmen wirst, wenn du es brauchst. Genau so funktioniert eine Stack in Java! Es ist eine "Last-In-First-Out" (LIFO) Datenstruktur und äußerst nützlich in der Programmierung.

Klassendeklaration

Beginnen wir mit den Grundlagen. In Java ist die Stack Klasse Teil des Pakets java.util. Um sie zu verwenden, musst du sie wie folgt importieren:

import java.util.Stack;

Die Stack Klasse erweitert die Vektor Klasse und implementiert Schnittstellen wie List, Collection, Iterable, Cloneable und Serializable. Keine Sorge, wenn diese Begriffe jetzt wie eine fremde Sprache klingen – wir kommen dran!

Klassenkonstruktoren

Die Stack Klasse hat nur einen Konstruktor:

Stack<E> stack = new Stack<E>();

Hier ist 'E' ein Platzhalter für den Typ der Elemente, die du in deinem Stack speichern möchtest. Es könnte Integer, String oder jeder andere Objekttyp sein. Zum Beispiel:

Stack<Integer> numberStack = new Stack<Integer>();
Stack<String> bookStack = new Stack<String>();

In der ersten Zeile erstellen wir einen Stack, der Integer speichert. In der zweiten maken wir einen Stack für Strings – perfekt für unsere Bücherhaufen-Analogie!

Klassenmethoden

Nun schauen wir uns die Hauptmethoden der Stack Klasse an. Ich werde sie in einer Tabelle für eine einfache Referenz darstellen:

Methode	Beschreibung
push(E item)	Fügt ein Element oben auf den Stack hinzu
pop()	Entfernt und gibt das oberste Element vom Stack zurück
peek()	Gibt das oberste Element zurück, ohne es zu entfernen
empty()	Überprüft, ob der Stack leer ist
search(Object o)	Sucht nach einem Objekt und gibt seine Position zurück

Lassen uns diese mit einigen Beispielen aufbrechen:

push(E item)

Stack<String> bookStack = new Stack<String>();
bookStack.push("Java für Anfänger");
bookStack.push("Datenstrukturen in Java");

Hier fügen wir Bücher zu unserem Stack hinzu. "Datenstrukturen in Java" ist jetzt über "Java für Anfänger".

pop()

String topBook = bookStack.pop();
System.out.println("Entferntes Buch: " + topBook);

Dies entfernt "Datenstrukturen in Java" von der Oberseite des Stacks und gibt es zurück.

peek()

String nextBook = bookStack.peek();
System.out.println("Nächstes zu lesendes Buch: " + nextBook);

Dies teilt uns das oberste Buch ohne es zu entfernen – in diesem Fall "Java für Anfänger".

empty()

if (bookStack.empty()) {
System.out.println("Keine Bücher mehr zu lesen!");
} else {
System.out.println("Du hast noch Bücher zu lesen!");
}

Dies überprüft, ob我们的 Stack leer ist. Es ist wie zu überprüfen, ob wir all unsere Bücher gelesen haben!

search(Object o)

int position = bookStack.search("Java für Anfänger");
if (position != -1) {
System.out.println("Buch gefunden an Position: " + position);
} else {
System.out.println("Buch nicht im Stack gefunden.");
}

Dies sucht nach einem Buch in unserem Stack. Bedenke, dass die Position von oben gezählt wird und das oberste Element an Position 1 ist.

Vererbte Methoden

Die Stack Klasse erbt auch Methoden von ihrer Elternklasse Vektor und den Schnittstellen, die sie implementiert. Einige nützliche vererbte Methoden umfassen:

• size(): Gibt die Anzahl der Elemente im Stack zurück
• contains(Object o): Überprüft, ob ein Objekt im Stack ist
• clear(): Entfernt alle Elemente aus dem Stack

Beispiel

Lassen uns alles zusammen mit einem lustigen Beispiel setzen. Stelle dir vor, wir halten unsere Pfannkuchen-Stack fest!

import java.util.Stack;

public class PancakeStack {
public static void main(String[] args) {
Stack<String> pancakes = new Stack<>();

// Pfannkuchen machen
pancakes.push("Einfach");
pancakes.push("Blaubeere");
pancakes.push("Schokoladenchip");

System.out.println("Pfannkuchen-Stack: " + pancakes);

// Den obersten Pfannkuchen essen
String eatenPancake = pancakes.pop();
System.out.println("Lecker! Just ate a " + eatenPancake + " Pfannkuchen.");

// Den nächsten Pfannkuchen überprüfen
System.out.println("Nächster Pfannkuchen ist: " + pancakes.peek());

// Mehr Pfannkuchen hinzufügen
pancakes.push("Banane");

// Stack-Größe überprüfen
System.out.println("Anzahl der übrigen Pfannkuchen: " + pancakes.size());

// Suchen nach einem Pfannkuchen
int position = pancakes.search("Einfach");
if (position != -1) {
System.out.println("Einfacher Pfannkuchen ist " + position + " vom oberen Ende.");
} else {
System.out.println("Keine einfachen Pfannkuchen mehr übrig!");
}
}
}

Ausgabe

Wenn du diesen Code ausführst, wirst du etwas wie folgt sehen:

Pfannkuchen-Stack: [Einfach, Blaubeere, Schokoladenchip]
Lecker! Just ate a Schokoladenchip Pfannkuchen.
Nächster Pfannkuchen ist: Blaubeere
Anzahl der übrigen Pfannkuchen: 3
Einfacher Pfannkuchen ist 3 vom oberen Ende.

Und da hast du es! Du hast gerade die Grundlagen der Java Stack Klasse gelernt. Denke daran, wie man Pfannkuchen oder Bücher stapelt, folgt eine Stack in Java dem "Last-In-First-Out"-Prinzip. Es ist ein leistungsstarkes Werkzeug, das du in vielen Programmier-Szenarien nützlich finden wirst.

Weiter üben, und bald wirst du Daten wie ein Profi stapeln und abnehmen! Frohes Coding, und möge dein Stack immer voller leckerer Pfannkuchen... Ich meine, nützlicher Daten sein!

Credits: Image by storyset