IL pila è una struttura dati lineare utilizzata per archiviare la raccolta di oggetti. È basato su Ultimo ad entrare, primo ad uscire (LIFO). Collezione Java framework fornisce molte interfacce e classi per archiviare la raccolta di oggetti. Uno di questi è il Classe di stack che fornisce diverse operazioni come push, pop, ricerca, ecc.

In questa sezione discuteremo di Classe dello stack Java , suo metodi, E strumento la struttura dei dati dello stack in a Programma Java . Ma prima di passare alla classe Java Stack, dai una rapida occhiata a come funziona lo stack.

La struttura dei dati dello stack ha le due operazioni più importanti che sono spingere E pop . L'operazione push inserisce un elemento nello stack e l'operazione pop rimuove un elemento dalla cima dello stack. Vediamo come funzionano sullo stack.

Mettiamo nello stack rispettivamente 20, 13, 89, 90, 11, 45, 18.

Rimuoviamo (pop) 18, 45 e 11 dallo stack.

Pila vuota: Se lo stack non ha elementi è noto come an pila vuota . Quando lo stack è vuoto il valore della variabile in alto è -1.

Quando inseriamo un elemento nello stack, il top è aumentato di 1 . Nella figura seguente,

• Premi 12, in alto=0
• Premi 6, in alto=1
• Premi 9, in alto=2

Quando estraiamo un elemento dallo stack il valore di top è diminuito di 1 . Nella figura seguente, ne abbiamo spuntati 9.

La tabella seguente mostra i diversi valori del top.

Classe dello stack Java

A Giava, Pila è una classe che rientra nel framework Collection che estende il Vettore classe. Implementa anche le interfacce Elenco, raccolta, iterabile, clonabile, serializzabile. Rappresenta lo stack di oggetti LIFO. Prima di utilizzare la classe Stack, dobbiamo importare il filejava.utilpacchetto. La classe dello stack organizzata nella gerarchia del framework Collections, come mostrato di seguito.

Costruttore di classi stack

La classe Stack contiene solo i file costruttore predefinito che crea uno stack vuoto.

Serie di fibonacci in Java

 public Stack() 

Creazione di una pila

Se vogliamo creare uno stack, per prima cosa importiamo il filejava.utilpackage e creare un oggetto della classe Stack.

 Stack stk = new Stack(); 

O

 Stack stk = new Stack(); 

Dove type denota il tipo di stack come Integer, String, ecc.

Metodi della classe Stack

Possiamo eseguire operazioni push, pop, peek e ricerca sullo stack. La classe Java Stack fornisce principalmente cinque metodi per eseguire queste operazioni. Insieme a questo, fornisce anche tutti i metodi di Classe vettoriale Java .

Metodo Stack Class empty()

IL vuoto() Il metodo della classe Stack controlla che lo stack sia vuoto o meno. Se lo stack è vuoto, restituisce vero, altrimenti restituisce falso. Possiamo anche utilizzare il metodo isEmpty() della classe Vector .

Sintassi

 public boolean empty() 

Ritorna: Il metodo restituisce true se lo stack è vuoto, altrimenti restituisce false.

come ottenere emoji Apple su Android

Nell'esempio seguente abbiamo creato un'istanza della classe Stack. Successivamente, abbiamo invocato il metodo empty() due volte. La prima volta che ritorna VERO perché non abbiamo inserito alcun elemento nello stack. Successivamente, abbiamo inserito gli elementi nello stack. Ancora una volta abbiamo invocato il metodo empty() che restituisce falso perché lo stack non è vuoto.

StackEmptyMethodExample.java

 import java.util.Stack; public class StackEmptyMethodExample { public static void main(String[] args) { //creating an instance of Stack class Stack stk= new Stack(); // checking stack is empty or not boolean result = stk.empty(); System.out.println('Is the stack empty? ' + result); // pushing elements into stack stk.push(78); stk.push(113); stk.push(90); stk.push(120); //prints elements of the stack System.out.println('Elements in Stack: ' + stk); result = stk.empty(); System.out.println('Is the stack empty? ' + result); } } 

Produzione:

 Is the stack empty? true Elements in Stack: [78, 113, 90, 120] Is the stack empty? false 

Metodo push() della classe Stack

Il metodo inserisce un elemento in cima allo stack. Funziona allo stesso modo del metodo addElement(item) della classe Vector. Passa un parametro articolo essere messo in pila.

Sintassi

 public E push(E item) 

Parametro: Un oggetto da spingere in cima alla pila.

Ritorna: Il metodo restituisce l'argomento che abbiamo passato come parametro.

Metodo pop() della classe Stack

Il metodo rimuove un oggetto in cima allo stack e restituisce lo stesso oggetto. Lancia VuotoStackException se la pila è vuota.

Sintassi

 public E pop() 

Ritorna: Restituisce un oggetto che si trova in cima allo stack.

Implementiamo lo stack in un programma Java ed eseguiamo operazioni push e pop.

StackPushPopExample.java

 import java.util.*; public class StackPushPopExample { public static void main(String args[]) { //creating an object of Stack class Stack stk = new Stack(); System.out.println('stack: ' + stk); //pushing elements into the stack pushelmnt(stk, 20); pushelmnt(stk, 13); pushelmnt(stk, 89); pushelmnt(stk, 90); pushelmnt(stk, 11); pushelmnt(stk, 45); pushelmnt(stk, 18); //popping elements from the stack popelmnt(stk); popelmnt(stk); //throws exception if the stack is empty try { popelmnt(stk); } catch (EmptyStackException e) { System.out.println('empty stack'); } } //performing push operation static void pushelmnt(Stack stk, int x) { //invoking push() method stk.push(new Integer(x)); System.out.println('push -> ' + x); //prints modified stack System.out.println('stack: ' + stk); } //performing pop operation static void popelmnt(Stack stk) { System.out.print('pop -> '); //invoking pop() method Integer x = (Integer) stk.pop(); System.out.println(x); //prints modified stack System.out.println('stack: ' + stk); } } 

Produzione:

 stack: [] push -> 20 stack: [20] push -> 13 stack: [20, 13] push -> 89 stack: [20, 13, 89] push -> 90 stack: [20, 13, 89, 90] push -> 11 stack: [20, 13, 89, 90, 11] push -> 45 stack: [20, 13, 89, 90, 11, 45] push -> 18 stack: [20, 13, 89, 90, 11, 45, 18] pop -> 18 stack: [20, 13, 89, 90, 11, 45] pop -> 45 stack: [20, 13, 89, 90, 11] pop -> 11 stack: [20, 13, 89, 90] 

Metodo peek() della classe Stack

Esamina l'elemento che si trova in cima allo stack. Lancia anche VuotoStackException se la pila è vuota.

Sintassi

 public E peek() 

Ritorna: Restituisce gli elementi principali dello stack.

Vediamo un esempio del metodo peek().

StackPeekMethodExample.java

protocollo UDP

 import java.util.Stack; public class StackPeekMethodExample { public static void main(String[] args) { Stack stk= new Stack(); // pushing elements into Stack stk.push('Apple'); stk.push('Grapes'); stk.push('Mango'); stk.push('Orange'); System.out.println('Stack: ' + stk); // Access element from the top of the stack String fruits = stk.peek(); //prints stack System.out.println('Element at top: ' + fruits); } } 

Produzione:

 Stack: [Apple, Grapes, Mango, Orange] Element at the top of the stack: Orange 

Metodo search() della classe Stack

Il metodo cerca l'oggetto nello stack dall'alto. Analizza un parametro che vogliamo cercare. Restituisce la posizione in base 1 dell'oggetto nello stack. L'oggetto più in alto della pila è considerato a distanza 1.

Supponiamo che o sia un oggetto nello stack che vogliamo cercare. Il metodo restituisce la distanza dalla parte superiore dello stack dell'occorrenza più vicina alla parte superiore dello stack. Utilizza equivale() metodo per cercare un oggetto nello stack.

Sintassi

 public int search(Object o) 

Parametro: o è l'oggetto desiderato da cercare.

Ritorna: Restituisce la posizione dell'oggetto dalla cima dello stack. Se restituisce -1, significa che l'oggetto non è nello stack.

Vediamo un esempio del metodo search().

stringa su int in Java

StackSearchMethodExample.java

 import java.util.Stack; public class StackSearchMethodExample { public static void main(String[] args) { Stack stk= new Stack(); //pushing elements into Stack stk.push('Mac Book'); stk.push('HP'); stk.push('DELL'); stk.push('Asus'); System.out.println('Stack: ' + stk); // Search an element int location = stk.search('HP'); System.out.println('Location of Dell: ' + location); } } 

Operazioni sullo stack Java

Dimensione della pila

Possiamo anche trovare la dimensione dello stack utilizzando il metodo size() della classe Vector . Restituisce il numero totale di elementi (dimensione dello stack) nello stack.

Sintassi

 public int size() 

Vediamo un esempio del metodo size() della classe Vector.

StackSizeExample.java

 import java.util.Stack; public class StackSizeExample { public static void main (String[] args) { Stack stk = new Stack(); stk.push(22); stk.push(33); stk.push(44); stk.push(55); stk.push(66); // Checks the Stack is empty or not boolean rslt=stk.empty(); System.out.println('Is the stack empty or not? ' +rslt); // Find the size of the Stack int x=stk.size(); System.out.println('The stack size is: '+x); } } 

Produzione:

 Is the stack empty or not? false The stack size is: 5 

Elementi ripetuti

Iterare significa recuperare gli elementi dello stack. Possiamo recuperare gli elementi dello stack utilizzando tre metodi diversi:

• Utilizzando iteratore() Metodo
• Utilizzando per ciascuno() Metodo
• Utilizzando elencoIteratore() Metodo

Utilizzando il metodo iterator()

È il metodo dell'interfaccia Iterator. Restituisce un iteratore sugli elementi nello stack. Prima di utilizzare il metodo iterator() importare il filejava.util.Iteratorpacchetto.

Sintassi

 Iterator iterator() 

Eseguiamo un'iterazione sullo stack.

StackIterationExample1.java

 import java.util.Iterator; import java.util.Stack; public class StackIterationExample1 { public static void main (String[] args) { //creating an object of Stack class Stack stk = new Stack(); //pushing elements into stack stk.push('BMW'); stk.push('Audi'); stk.push('Ferrari'); stk.push('Bugatti'); stk.push('Jaguar'); //iteration over the stack Iterator iterator = stk.iterator(); while(iterator.hasNext()) { Object values = iterator.next(); System.out.println(values); } } } 

Produzione:

gzip per Linux

 BMW Audi Ferrari Bugatti Jaguar 

Utilizzando il metodo forEach()

Java fornisce un metodo forEach() per scorrere gli elementi. Il metodo è definito nell'art Iterabile E Flusso interfaccia.

Sintassi

 default void forEach(Consumeraction) 

Iteriamo sullo stack utilizzando il metodo forEach().

StackIterationExample2.java

 import java.util.*; public class StackIterationExample2 { public static void main (String[] args) { //creating an instance of Stack class Stack stk = new Stack(); //pushing elements into stack stk.push(119); stk.push(203); stk.push(988); System.out.println('Iteration over the stack using forEach() Method:'); //invoking forEach() method for iteration over the stack stk.forEach(n -> { System.out.println(n); }); } } 

Produzione:

 Iteration over the stack using forEach() Method: 119 203 988 

Utilizzando il metodo listIterator()

Questo metodo restituisce un iteratore di elenco sugli elementi nell'elenco menzionato (in sequenza), a partire dalla posizione specificata nell'elenco. Itera lo stack dall'alto verso il basso.

Sintassi

 ListIterator listIterator(int index) 

Parametro: Il metodo analizza un parametro denominato indice.

Ritorna: Questo metodo restituisce un iteratore di elenco sugli elementi, in sequenza.

Eccezione: Lancia IndexOutOfBoundsException se l'indice è fuori range.

Iteriamo sullo stack utilizzando il metodo listIterator().

StackIterationExample3.java

 import java.util.Iterator; import java.util.ListIterator; import java.util.Stack; public class StackIterationExample3 { public static void main (String[] args) { Stack stk = new Stack(); stk.push(119); stk.push(203); stk.push(988); ListIterator ListIterator = stk.listIterator(stk.size()); System.out.println('Iteration over the Stack from top to bottom:'); while (ListIterator.hasPrevious()) { Integer avg = ListIterator.previous(); System.out.println(avg); } } } 

Produzione:

 Iteration over the Stack from top to bottom: 988 203 119