java stack tutorial stack class implementation with examples
Questo tutorial spiega cos'è lo stack in Java, Java Stack Class, Stack API Methods, Stack Implementation using Array & Linked List with the help of examples:
Uno stack è una struttura dati ordinata appartenente a Java Collection Framework. In questa raccolta, gli elementi vengono aggiunti e rimossi solo da un'estremità. L'estremità in cui gli elementi vengono aggiunti e rimossi è chiamata 'Top of the Stack'.
Poiché l'aggiunta e l'eliminazione vengono eseguite solo a un'estremità, il primo elemento aggiunto alla pila sembra essere l'ultimo elemento rimosso dalla pila. Pertanto lo stack è chiamato struttura dati LIFO (Last-in, First-out).
=> Dai un'occhiata alla guida per principianti di Java qui
Cosa imparerai:
- Collezione Java Stack
- Conclusione
Collezione Java Stack
Di seguito viene fornita una rappresentazione pittorica della pila.
Come mostrato nella sequenza di rappresentazione sopra, inizialmente lo stack è vuoto e la parte superiore dello stack è impostata su -1. Quindi iniziamo un'operazione 'push' che viene utilizzata per aggiungere un elemento allo stack.
come guardare netflix con VPN
Quindi nella seconda rappresentazione, spingiamo l'elemento 10. A questo punto, il massimo viene incrementato. Spingiamo nuovamente l'elemento 20 nella pila incrementando ulteriormente la sommità.
Nell'ultima rappresentazione, iniziamo un'operazione 'pop'. Questa operazione viene utilizzata per rimuovere un elemento dallo stack. Un elemento attualmente puntato a 'Top' viene rimosso dall'operazione pop.
Una struttura di dati dello stack supporta le seguenti operazioni:
- Spingere: Aggiunge un elemento allo stack. Di conseguenza, il valore della parte superiore viene incrementato.
- Pop: Un elemento viene rimosso dalla pila. Dopo l'operazione pop, il valore del top viene decrementato.
- Sbirciare: Questa operazione viene utilizzata per cercare o cercare un elemento. Il valore del top non viene modificato.
La parte superiore della pila che viene utilizzata come fine per aggiungere / rimuovere elementi dalla pila può anche avere vari valori in un particolare istante. Se la dimensione dello stack è N, la parte superiore dello stack avrà i seguenti valori in condizioni diverse a seconda dello stato in cui si trova lo stack.
| Stato dello stack | Massimo valore |
|---|---|
| Stack vuoto | -1 |
| Un elemento nella pila | 0 |
| Stack pieno | N-1 |
| Overflow (elementi> N) | N |
Classe Stack in Java
Java Collection Framework fornisce una classe denominata 'Stack'. Questa classe Stack estende la classe Vector e implementa la funzionalità della struttura dati Stack.
Il diagramma seguente mostra la gerarchia della classe Stack.
Come mostrato nel diagramma sopra, la classe Stack eredita la classe Vector che a sua volta implementa l'interfaccia List Interface of Collection.
La classe Stack fa parte del pacchetto java.util. Per includere la classe Stack nel programma, possiamo usare l'istruzione import come segue.
import java.util.*; o
import java.util.Stack; Crea uno stack in Java
Una volta importata la classe Stack, possiamo creare un oggetto Stack come mostrato di seguito:
Stack mystack = new Stack(); Possiamo anche creare un tipo generico di oggetto classe Stack come segue:
Stack myStack = new Stack; Qui data_type può essere qualsiasi tipo di dati valido in Java.
Per esempio ,possiamo creare i seguenti oggetti della classe Stack.
Stack stack_obj = new Stack(); Stack str_stack = new Stack(); Stack metodi API in Java
La classe Stack fornisce metodi per aggiungere, rimuovere e cercare dati nello Stack. Fornisce inoltre un metodo per verificare se lo stack è vuoto. Discuteremo questi metodi nella sezione seguente.
Stack Push Operation
L'operazione push viene utilizzata per inserire o aggiungere elementi nello stack. Dopo aver creato un'istanza dello stack, possiamo utilizzare l'operazione push per aggiungere gli elementi del tipo di oggetto dello stack allo stack.
La parte di codice seguente viene utilizzata per inizializzare uno stack intero con i valori.
Stack myStack = new Stack(); myStack.push(10); myStack.push(15); myStack.push(20); Lo stack iniziale ottenuto come risultato dell'esecuzione del codice sopra è mostrato di seguito:
Se eseguiamo un'altra operazione push () come mostrato di seguito,
push(25); Lo stack risultante sarà:
Operazione Stack Pop
Possiamo rimuovere l'elemento dallo stack utilizzando l'operazione 'pop'. L'elemento puntato dal Top attualmente è saltato fuori dalla pila.
La parte di codice seguente consente di ottenere questo risultato.
Stack intStack = new Stack(); intStack.push(100); intStack.push(200); int val = intStack.pop(); La variabile val conterrà il valore 200 poiché era l'ultimo elemento inserito nello stack.
La rappresentazione dello stack per l'operazione push e pop è la seguente:
Stack Peek Operation
L'operazione peek restituisce il Top of the stack senza rimuovere l'elemento. Nell'esempio di stack precedente, 'intStack.peek ()' restituirà 200.
Stack isEmpty Operation
L'operazione isEmpty () della classe Stack controlla se l'oggetto stack è vuoto. Restituisce true se lo Stack non contiene elementi, altrimenti restituisce false.
Operazione di ricerca nello stack
Possiamo cercare un elemento nello stack utilizzando l'operazione search (). L'operazione search () restituisce l'indice dell'elemento cercato. Questo indice viene conteggiato dalla cima della pila.
Stack intStack = new Stack (); intStack.push (100); intStack.push (200); int index = inStack.search(100); //index will have the value 2.Dimensione dello stack
La dimensione dell'oggetto Stack è data da java.util.Stack.size () metodo. Restituisce il numero totale di elementi nello stack.
L'esempio seguente stampa la dimensione dello stack.
Stack myStack = new Stack(); myStack.push(100); myStack.push(200); myStack.push(300); System.out.println('Stack size:' + myStack.size()); //Stack size: 3 Stampa / itera elementi dello stack
Possiamo dichiarare un iteratore per lo Stack e quindi attraversare l'intero Stack usando questo iteratore. In questo modo possiamo visitare e stampare ogni elemento dello stack uno per uno.
Il programma seguente mostra come iterare Stack utilizzando un iteratore.
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() + ' '); } } }Produzione:
Stack elementi:
PUNE MUMBAI NASHIK
Stack utilizzando Java 8
Possiamo anche stampare o attraversare gli elementi dello stack utilizzando le funzionalità di Java 8 come le API Stream, i costrutti forEach e forEachRemaining.
Il seguente programma dimostra l'utilizzo dei costrutti Java 8 per attraversare lo stack.
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 + ' '); }); } } Produzione:
Stack elementi utilizzando Java 8 forEach:
PUNE MUMBAI NASHIK
Stack elementi utilizzando Java 8 forEachRemaining:
PUNE MUMBAI NASHIK
Implementazione dello stack in Java
Il seguente programma implementa lo stack dettagliato che mostra le varie operazioni dello stack.
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()); } } Produzione:
Stack iniziale: ()
Lo stack è vuoto? : vero
Stack dopo l'operazione push: (10, 20, 30, 40)
Elemento saltato fuori: 40
Stack dopo l'operazione Pop: (10, 20, 30)
Elemento 10 trovato nella posizione: 3
Stack è vuoto? : falso
converte un carattere in una stringa c ++
Stack To Array in Java
La struttura dei dati dello stack può essere convertita in un Array utilizzando il metodo 'toArray ()' della classe Stack.
Il seguente programma mostra questa conversione.
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 Produzione:
I contenuti dello stack: (PUNE, MUMBAI, NASHIK)
Il contenuto dell'array:
PUNE MUMBAI NASHIK
Implementazione dello stack in Java mediante array
Lo stack può essere implementato utilizzando un Array. Tutte le operazioni sullo stack vengono eseguite utilizzando un array.
Il programma seguente mostra l'implementazione dello Stack utilizzando un array.
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(); } } Produzione:
Stack iniziale vuoto: vero
Dopo l'operazione push ...
Stampa di elementi della pila ...
40 30 20 10
Articolo spuntato: 40
Articolo spuntato: 30
Dopo l'operazione Pop ...
Stampa di elementi della pila ...
20 10
Implementazione dello stack tramite elenco collegato
Lo stack può anche essere implementato utilizzando un elenco collegato, proprio come abbiamo fatto con gli array. Un vantaggio dell'utilizzo di un elenco collegato per l'implementazione dello stack è che può crescere o ridursi dinamicamente. Non abbiamo bisogno di una limitazione della dimensione massima come negli array.
Il seguente programma implementa un elenco collegato per eseguire operazioni sullo stack.
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()); } } Produzione:
Stack elementi:
1-> 3-> 5-> 7-> 9->
Stack in alto: 1
Pop due elementi
Stack elementi:
5-> 7-> 9->
apri i file .jar windows 10
Nuovo Stack top: 5
Domande frequenti
D # 1) Cosa sono gli stack in Java?
Risposta: Uno stack è una struttura dati LIFO (Last in, First out) per la memorizzazione degli elementi. Gli elementi dello stack vengono aggiunti o rimossi dallo stack da un'estremità denominata Top of the stack.
L'aggiunta di un elemento allo stack viene eseguita utilizzando l'operazione Push. L'eliminazione degli elementi viene eseguita utilizzando l'operazione pop. In Java, uno stack viene implementato utilizzando la classe Stack.
D # 2) Stack è una raccolta in Java?
Risposta: Sì. Lo stack è una raccolta legacy in Java disponibile dall'API Collection in Java 1.0 in poi. Stack eredita la classe Vector dell'interfaccia List.
D # 3) Stack è un'interfaccia?
Risposta: Lo stack di interfaccia è un'interfaccia che descrive la struttura last-in, first-out e viene utilizzata per memorizzare lo stato dei problemi ricorsivi.
D # 4) A cosa servono gli stack?
Risposta: Di seguito sono riportate le principali applicazioni dello stack:
- Valutazione e conversioni di espressioni: Stack viene utilizzato per convertire le espressioni in suffisso, infisso e prefisso. Viene anche utilizzato per valutare queste espressioni.
- Lo stack viene utilizzato anche per analizzare gli alberi della sintassi.
- Lo stack viene utilizzato per controllare le parentesi in un'espressione.
- Lo stack viene utilizzato per risolvere i problemi di backtracking.
- Le chiamate di funzione vengono valutate utilizzando gli stack.
D # 5) Quali sono i vantaggi dello stack?
Risposta: Le variabili memorizzate nello stack vengono distrutte automaticamente quando vengono restituite. Gli stack sono una scelta migliore quando la memoria viene allocata e deallocata. Le pile puliscono anche la memoria. A parte questo, gli stack possono essere utilizzati efficacemente per valutare le espressioni e analizzare le espressioni.
Conclusione
Questo completa il nostro tutorial sugli stack in Java. La classe Stack fa parte dell'API di raccolta e supporta le operazioni push, pop, peek e di ricerca. Gli elementi vengono aggiunti o rimossi alla / dalla pila solo a un'estremità. Questa estremità è chiamata la parte superiore della pila.
In questo tutorial, abbiamo visto tutti i metodi supportati dalla classe stack. Abbiamo anche implementato lo stack utilizzando array ed elenchi collegati.
Procederemo con altre classi di raccolta nei nostri tutorial successivi.
=> Leggere attraverso la serie di formazione Easy Java
Lettura consigliata
- Tutorial Java Reflection con esempi
- Tutorial di classe per scanner Java con esempi
- Che cos'è una tabella hash Java - Implementazione ed esempio di tabella hash
- Cos'è Java Vector | Tutorial Java Vector Class con esempi
- Tutorial Java Array Class - classe java.util.Arrays con esempi
- Nozioni di base su Java: sintassi Java, classe Java e concetti principali di Java
- LinkedHashMap in Java - Esempio e implementazione di LinkedHashMap
- Tutorial Java SWING: contenitore, componenti e gestione degli eventi
