Giava Quadro della raccolta fornisce una classe Stack che modella e implementa a Il diagramma seguente mostra il gerarchia della classe Stack :
La classe ne supporta uno costruttore predefinito Pila() a cui è abituato creare una pila vuota .
Dichiarazione:
public class Stack extends Vector>
Tutte le interfacce implementate:
- Serializzabile: È un'interfaccia marcatore che le classi devono implementare se devono essere serializzate e deserializzate.
- Clonabile: Si tratta di un'interfaccia in Java che deve essere implementata da una classe per consentire la clonazione dei suoi oggetti.
- Iterabile: Questa interfaccia rappresenta una raccolta di oggetti che è iterabile, ovvero che può essere iterato.
- Collezione: Una Collezione rappresenta un gruppo di oggetti conosciuti come i suoi elementi. L'interfaccia Collection viene utilizzata per passare raccolte di oggetti dove si desidera la massima generalità.
- Elenco: L'interfaccia Elenco fornisce un modo per archiviare la raccolta ordinata. È un'interfaccia figlia di Collection.
- Accesso casuale: Si tratta di un'interfaccia marcatore utilizzata dalle implementazioni List per indicare che supportano l'accesso casuale veloce (generalmente a tempo costante).
Come creare una pila?
Per creare uno stack, dobbiamo importare java.util.stack package e utilizzare il costruttore Stack() di questa classe. L'esempio seguente crea uno Stack vuoto.
Stack stack = nuovo Stack();
Qui E è il tipo di oggetto.
Esempio:
Giava
// 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>);> >}> }> |
esempi di macchina Moore
>
>
Produzione:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Esecuzione di varie operazioni sulla classe Stack
1. Aggiunta di elementi: Per aggiungere un elemento allo stack, possiamo usare il metodo push() . Questo spingere() L'operazione posiziona l'elemento in cima allo stack.
Giava
// 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);> >}> }> |
>
>
Produzione:
[4, All, Geeks] [Geeks, For, Geeks]>
2. Accesso all'elemento: Per recuperare o recuperare il primo elemento dello Stack o l'elemento presente in cima allo Stack, possiamo usare sbirciare() metodo. L'elemento recuperato non viene eliminato o rimosso dallo stack.
Giava
// 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);> >}> }> |
errore: impossibile trovare o caricare la classe principale
>
>
Produzione:
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. Rimozione di elementi: Per estrarre un elemento dallo stack, possiamo usare il pop() metodo. L'elemento viene estratto dalla cima dello stack e rimosso dallo stesso.
Giava
// 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);> >}> }> |
>
>
Produzione:
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30]>
Esempio
In Java, la classe Stack è una sottoclasse della classe Vector e rappresenta uno stack di oggetti LIFO (last-in-first-out). Estende la classe Vector per consentire una facile implementazione della struttura dei dati dello stack.
Ecco un esempio di come puoi utilizzare la classe Stack in Java:
Giava
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());> >}> >}> }> |
>
>Produzione
4 3 2 1>
In questo esempio, importiamo prima la classe Stack dal pacchetto java.util. Creiamo quindi un nuovo oggetto Stack chiamato stack utilizzando il costruttore predefinito. Inseriamo quattro numeri interi nello stack utilizzando il metodo push(). Quindi estraiamo gli elementi dallo stack utilizzando il metodo pop() all'interno di un ciclo while. Il metodo isEmpty() viene utilizzato per verificare se lo stack è vuoto prima di tentare di estrarre un elemento.
Questo codice crea uno stack di numeri interi e inserisce 4 numeri interi nello stack nell'ordine 1 -> 2 -> 3 -> 4. Quindi estraiamo gli elementi dallo stack uno per uno utilizzando il metodo pop(), che rimuove e restituisce il elemento superiore dello stack. Poiché lo stack segue l'ordine LIFO (last-in-first-out), gli elementi vengono estratti nell'ordine inverso rispetto all'inserimento, ottenendo l'output mostrato sopra.
La classe Stack fornisce diversi altri metodi per manipolare lo stack, come peek() per recuperare l'elemento in cima senza rimuoverlo, search() per cercare un elemento nello stack e restituirne la posizione e size() per restituire l'elemento corrente dimensione della pila. La classe Stack fornisce inoltre diversi costruttori per creare uno stack con una capacità iniziale specificata o copiare uno stack esistente.
np significa
Metodi nella classe Stack
| METODO | DESCRIZIONE |
|---|---|
| vuoto() | Restituisce vero se non c'è nulla in cima allo stack. Altrimenti restituisce false. |
| sbirciare() | Restituisce l'elemento in cima allo stack, ma non lo rimuove. |
| pop() | Rimuove e restituisce l'elemento superiore dello stack. Una 'EmptyStackException' Viene lanciata un'eccezione se chiamiamo pop() quando lo stack invocante è vuoto. |
| push(Elemento oggetto) | Spinge un elemento in cima allo stack. |
| ricerca(elemento oggetto) | Determina se un oggetto esiste nello stack. Se l'elemento viene trovato, Restituisce la posizione dell'elemento dalla cima dello stack. Altrimenti restituisce -1. |
Metodi ereditati dalla classe java.util.Vector
| METODO | DESCRIZIONE |
|---|---|
| aggiungi(Oggetto oggetto) | Aggiunge l'elemento specificato alla fine di questo Vector. |
| add(indice int, oggetto oggetto) | Inserisce l'elemento specificato nella posizione specificata in questo Vector. |
| addAll(Raccolta c) | Aggiunge tutti gli elementi nella raccolta specificata alla fine di questo vettore, nell'ordine in cui vengono restituiti dall'iteratore della raccolta specificata. |
| addAll(int indice, Collezione c) | Inserisce tutti gli elementi nella Collection specificata in questo Vector nella posizione specificata. |
| addElement(Oggetto o) | Aggiunge il componente specificato alla fine di questo vettore, aumentandone la dimensione di uno. |
| capacità() | Restituisce la capacità corrente di questo vettore. |
| chiaro() | Rimuove tutti gli elementi da questo vettore. |
| clone() | Restituisce un clone di questo vettore. |
| contiene(Oggetto o) | Restituisce vero se questo vettore contiene l'elemento specificato. |
| contieneTutto(Collezione c) | Restituisce vero se questo Vector contiene tutti gli elementi nella Collection specificata. |
| copyInto(Oggetto []array) | Copia i componenti di questo vettore nell'array specificato. |
| elementoAt(int indice) | Restituisce il componente in corrispondenza dell'indice specificato. |
| elementi() | Restituisce un'enumerazione dei componenti di questo vettore. |
| GuaranteeCapacità(int MinCapacità) | Aumenta la capacità di questo vettore, se necessario, per garantire che possa reggere almeno il numero di componenti specificati dall'argomento capacità minima. |
| equivale() | Confronta l'oggetto specificato con questo vettore per verificarne l'uguaglianza. |
| primoElemento() | Restituisce il primo componente (l'elemento con indice 0) di questo vettore. |
| get(indice int) | Restituisce l'elemento nella posizione specificata in questo Vector. |
| codice hash() | Restituisce il valore del codice hash per questo vettore. |
| indiceOf(Oggetto o) | Restituisce l'indice della prima occorrenza dell'elemento specificato in questo vettore o -1 se questo vettore non contiene l'elemento. |
| indiceOf(Oggetto o, indice int) | Restituisce l'indice della prima occorrenza dell'elemento specificato in questo vettore, effettuando una ricerca in avanti dall'indice, oppure restituisce -1 se l'elemento non viene trovato. |
| insertElementAt(Oggetto o, indice int) | Inserisce l'oggetto specificato come componente in questo vettore in corrispondenza dell'indice specificato. |
| è vuoto() | Verifica se questo vettore non ha componenti. |
| iteratore() | Restituisce un iteratore sugli elementi in questo elenco nella sequenza corretta. |
| ultimoelemento() | Restituisce l'ultimo componente del vettore. |
| ultimoIndiceOf(Oggetto o) | Restituisce l'indice dell'ultima occorrenza dell'elemento specificato in questo vettore o -1 Se questo vettore non contiene l'elemento. |
| lastIndexOf(Oggetto o, indice int) | Restituisce l'indice dell'ultima occorrenza dell'elemento specificato in questo vettore, effettuando una ricerca all'indietro dall'indice oppure restituisce -1 se l'elemento non viene trovato. |
| elencoIteratore() | Restituisce un iteratore di elenco sugli elementi in questo elenco (nella sequenza corretta). |
| listIterator(int indice) | Restituisce un iteratore di lista sugli elementi in questa lista (nella sequenza corretta), a partire dalla posizione specificata nell'elenco. |
| rimuovi(indice int) | Rimuove l'elemento nella posizione specificata in questo Vector. |
| rimuovi(Oggetto o) | Rimuove la prima occorrenza dell'elemento specificato in questo Vector. Se il Vector non contiene l'elemento, rimane invariato. |
| rimuoviTutto(Raccolta c) | Rimuove da questo Vector tutti i suoi elementi contenuti nella Collection specificata. |
| rimuoviTuttiGliElementi() | Rimuove tutti i componenti da questo vettore e ne imposta la dimensione su zero. |
| rimuoviElemento(Oggetto o) | Rimuove la prima occorrenza (con l'indice più basso) dell'argomento da questo vettore. |
| rimuoviElementoAt(int indice) | Elimina il componente in corrispondenza dell'indice specificato. |
| rimuoviIntervallo(int dall'Indice, int all'Indice) | Rimuove da questo elenco tutti gli elementi il cui indice è compreso tra fromIndex, inclusivo, e toIndex, esclusivo. |
| keepAll(Raccolta c) | Mantiene solo gli elementi in questo Vector contenuti nella Collection specificata. |
| set(int indice, Oggetto o) | Sostituisce l'elemento nella posizione specificata in questo Vector con l'elemento specificato. |
| setElementAt(Oggetto o, indice int) | Imposta il componente all'indice specificato di questo vettore come oggetto specificato. |
| setSize(int newSize) | Imposta la dimensione di questo vettore. |
| misurare() | Restituisce il numero di componenti in questo vettore. |
| sottoLista(int dall'Indice, int all'Indice) | Restituisce una visualizzazione della parte di questo elenco compresa tra fromIndex, compreso, e toIndex, esclusivo. |
| toArray() | Restituisce un array contenente tutti gli elementi di questo Vector nell'ordine corretto. |
| toArray(Oggetto []array) | Restituisce un array contenente tutti gli elementi di questo Vector nell'ordine corretto; il tempo di esecuzione il tipo dell'array restituito è quello dell'array specificato. |
| accordare() | Restituisce una rappresentazione stringa di questo Vector, contenente la rappresentazione String di ciascun elemento. |
| tagliare alla dimensione() | Taglia la capacità di questo vettore in modo che corrisponda alla dimensione corrente del vettore. |
Dare priorità all'uso di Riguardo a cosa sopra lo stack -:
La classe Stack in Java è una classe legacy e eredita da Vettore in Giava . È una classe thread-safe e quindi comporta un sovraccarico quando non è necessaria la sicurezza del thread. Si consiglia di utilizzare ArrayDeque per l'implementazione dello stack poiché è più efficiente in un ambiente a thread singolo.
Giava
// 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());> >}> }> |
caratteristiche di Java
>
>
Produzione:
B B>
Un motivo in più per utilizzare Deque over Stack è che Deque ha la capacità di utilizzare i flussi convertiti in elenchi mantenendo applicato il concetto LIFO mentre Stack no.
Giava
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(); } }> |
>
>Produzione
Using Stack - 1 2 Using Deque - 2 1>