Guida all'uso della Classe Stack di Java: Per Principianti

Introduzione

Ciao, futuri sviluppatori Java! Oggi entreremo nel fascinante mondo della classe Stack di Java. Non preoccuparti se non hai mai scritto una riga di codice prima – sarò la tua guida amichevole in questo avventuroso viaggio.

Immagina di organizzare i tuoi libri. Li metti uno sopra l'altro, formando una pila. L'ultimo libro che metti nella pila è il primo che prenderai quando ne avrai bisogno. Exactamente così funziona una Stack in Java! È una struttura dati "Last-In-First-Out" (LIFO) ed è incredibilmente utile nella programmazione.

Dichiarazione della Classe

Iniziamo dagli elementari. In Java, la classe Stack fa parte del pacchetto java.util. Per usarla, devi importarla così:

import java.util.Stack;

La classe Stack estende la classe Vector e implementa interfacce come List, Collection, Iterable, Cloneable e Serializable. Non preoccuparti se questi termini sembrano un linguaggio alieno al momento – arriveremo lì!

Costruttori della Classe

La classe Stack ha un solo costruttore:

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

Qui, 'E' è un segnaposto per il tipo di elementi che vuoi memorizzare nella tua pila. Può essere Integer, String o qualsiasi altro tipo di oggetto. Per esempio:

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

Nella prima riga, stiamo creando una pila che conterrà interi. Nella seconda, stiamo creando una pila per stringhe – perfetta per la nostra analogia della pila di libri!

Metodi della Classe

Ora, esaminiamo i metodi principali della classe Stack. Li presenterò in una tabella per una facile consultazione:

Metodo	Descrizione
push(E item)	Aggiunge un elemento in cima alla pila
pop()	Rimuove e restituisce l'elemento in cima alla pila
peek()	Restituisce l'elemento in cima senza rimuoverlo
empty()	Controlla se la pila è vuota
search(Object o)	Cerca un oggetto e restituisce la sua posizione

Diamo un'occhiata più da vicino con alcuni esempi:

push(E item)

Stack<String> bookStack = new Stack<String>();
bookStack.push("Java per Principianti");
bookStack.push("Strutture Dati in Java");

Qui, stiamo aggiungendo libri alla nostra pila. "Strutture Dati in Java" è ora in cima a "Java per Principianti".

pop()

String topBook = bookStack.pop();
System.out.println("Libro rimosso: " + topBook);

Questo rimuove "Strutture Dati in Java" dalla cima della pila e lo restituisce.

peek()

String nextBook = bookStack.peek();
System.out.println("Prossimo libro da leggere: " + nextBook);

Questo ci dice il libro in cima senza rimuoverlo – in questo caso, "Java per Principianti".

empty()

if (bookStack.empty()) {
System.out.println("Nessun altro libro da leggere!");
} else {
System.out.println("Hai ancora libri da leggere!");
}

Questo controlla se la nostra pila è vuota. È come controllare se abbiamo finito tutti i nostri libri!

search(Object o)

int position = bookStack.search("Java per Principianti");
if (position != -1) {
System.out.println("Libro trovato nella posizione: " + position);
} else {
System.out.println("Libro non trovato nella pila.");
}

Questo cerca un libro nella nostra pila. Ricorda, la posizione è contata dalla cima, e l'elemento in cima è alla posizione 1.

Metodi Ereditati

La classe Stack eredita anche metodi dalla sua classe padre, Vector, e dalle interfacce che implementa. Alcuni metodi ereditati utili includono:

• size(): Restituisce il numero di elementi nella pila
• contains(Object o): Controlla se un oggetto è nella pila
• clear(): Rimuove tutti gli elementi dalla pila

Esempio

Mettiamo tutto insieme con un esempio divertente. Immagina di tenere traccia della nostra pila di pancake!

import java.util.Stack;

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

// Preparazione dei pancake
pancakes.push("Plain");
pancakes.push("Blueberry");
pancakes.push("Chocolate Chip");

System.out.println("Pila di pancake: " + pancakes);

// Mangiare il pancake in cima
String eatenPancake = pancakes.pop();
System.out.println("Yum! Ho appena mangiato un pancake " + eatenPancake + ".");

// Controllare il prossimo pancake
System.out.println("Il prossimo pancake è: " + pancakes.peek());

// Aggiungere più pancake
pancakes.push("Banana");

// Controllare la dimensione della pila
System.out.println("Numero di pancake rimasti: " + pancakes.size());

// Cerca un pancake
int position = pancakes.search("Plain");
if (position != -1) {
System.out.println("Il pancake Plain è " + position + " dalla cima.");
} else {
System.out.println("Nessun pancake plain rimasto!");
}
}
}

Output

Quando esegui questo codice, vedrai qualcosa del genere:

Pila di pancake: [Plain, Blueberry, Chocolate Chip]
Yum! Ho appena mangiato un pancake Chocolate Chip.
Il prossimo pancake è: Blueberry
Numero di pancake rimasti: 3
Il pancake Plain è 3 dalla cima.

Eccoci! Hai appena imparato la base della classe Stack di Java. Ricorda, come impilare pancake o libri, una Stack in Java segue il principio "Last-In-First-Out". È uno strumento potente che troverai utile in molte situazioni di programmazione.

continua a praticare, e presto sarai in grado di impilare e smontare dati come un professionista! Buon coding, e che le tue pile siano sempre piene di deliziosi pancake... beh, si intende, dati utili!

Credits: Image by storyset