java stack tutorial stack class implementation with examples
Este tutorial explica o que é Stack em Java, Java Stack Class, Stack API Methods, Stack Implementation usando Array & Linked List com a ajuda de exemplos:
Uma pilha é uma estrutura de dados ordenada pertencente ao Java Collection Framework. Nesta coleção, os elementos são adicionados e removidos de apenas uma extremidade. O final em que os elementos são adicionados e removidos é chamado de “Topo da Pilha”.
Como a adição e a exclusão são feitas apenas em uma extremidade, o primeiro elemento adicionado à pilha passa a ser o último elemento removido da pilha. Portanto, a pilha é chamada de estrutura de dados LIFO (Last-in, First-out).
=> Dê uma olhada no guia para iniciantes em Java aqui
O que você aprenderá:
- Java Stack Collection
- Conclusão
Java Stack Collection
Uma representação pictórica da pilha é fornecida abaixo.
Conforme mostrado na sequência de representação acima, inicialmente a pilha está vazia e o topo da pilha é definido como -1. Em seguida, iniciamos uma operação “push” que é usada para adicionar um elemento à pilha.
Portanto, na segunda representação, pressionamos o elemento 10. Nesse ponto, o topo é incrementado. Novamente empurramos o elemento 20 na pilha, incrementando ainda mais o topo.
Na última representação, iniciamos uma operação “pop”. Esta operação é usada para remover um elemento da pilha. Um elemento atualmente apontado para ‘Top’ é removido pela operação pop.
Uma estrutura de pilha de dados suporta as seguintes operações:
converter youtube para mp3 grátis seguro
- Empurre: Adiciona um elemento à pilha. Como resultado, o valor do topo é incrementado.
- Pop: Um elemento é removido da pilha. Após a operação de pop, o valor do topo é decrementado.
- Olhadinha: Esta operação é usada para pesquisar ou pesquisar um elemento. O valor do topo não é modificado.
O topo da pilha que é usado como um fim para adicionar / remover elementos da pilha também pode ter vários valores em um determinado instante. Se o tamanho da pilha for N, o topo da pilha terá os seguintes valores em diferentes condições, dependendo do estado em que a pilha está.
| Status da pilha | Valor superior |
|---|---|
| Pilha vazia | -1 |
| Um elemento na pilha | 0 |
| Pilha cheia | N-1 |
| Overflow (elementos> N) | N |
Classe de pilha em Java
O Java Collection Framework fornece uma classe chamada “Stack”. Esta classe Stack estende a classe Vector e implementa a funcionalidade da estrutura de dados Stack.
O diagrama abaixo mostra a hierarquia da classe Stack.
Conforme mostrado no diagrama acima, a classe Stack herda a classe Vector que, por sua vez, implementa a interface List Interface of Collection.
A classe Stack faz parte do pacote java.util. Para incluir a classe Stack no programa, podemos usar a instrução import da seguinte maneira.
import java.util.*; ou
import java.util.Stack; Crie uma pilha em Java
Depois de importar a classe Stack, podemos criar um objeto Stack conforme mostrado abaixo:
Stack mystack = new Stack(); Também podemos criar um tipo genérico de objeto de classe Stack da seguinte maneira:
Stack myStack = new Stack; Aqui, data_type pode ser qualquer tipo de dados válido em Java.
Por exemplo ,podemos criar os seguintes objetos da classe Stack.
Stack stack_obj = new Stack(); Stack str_stack = new Stack(); Métodos da Stack API em Java
A classe Stack fornece métodos para adicionar, remover e pesquisar dados na Stack. Também fornece um método para verificar se a pilha está vazia. Discutiremos esses métodos na seção a seguir.
Operação Stack Push
A operação push é usada para enviar ou adicionar elementos à pilha. Depois de criar uma instância de pilha, podemos usar a operação push para adicionar os elementos do tipo de objeto de pilha à pilha.
O código a seguir é usado para inicializar uma pilha de inteiros com os valores.
Stack myStack = new Stack(); myStack.push(10); myStack.push(15); myStack.push(20); A pilha inicial obtida como resultado da parte da execução do código acima é mostrada abaixo:
Se realizarmos outra operação push () conforme mostrado abaixo,
push(25); A pilha resultante será:
Operação Stack Pop
Podemos remover o elemento da pilha usando a operação “pop”. O elemento apontado pelo Topo no momento é retirado da pilha.
O seguinte trecho de código consegue isso.
Stack intStack = new Stack(); intStack.push(100); intStack.push(200); int val = intStack.pop(); A variável val conterá o valor 200, pois foi o último elemento colocado na pilha.
A representação da pilha para a operação push e pop é a seguinte:
Operação Stack Peek
A operação peek retorna o topo da pilha sem remover o elemento. No exemplo de pilha acima, “intStack.peek ()” retornará 200.
Operação Stack isEmpty
A operação isEmpty () da classe Stack verifica se o objeto da pilha está vazio. Ele retorna verdadeiro se a pilha não tiver elementos, senão retorna falso.
Operação de pesquisa de pilha
Podemos pesquisar um elemento na pilha usando a operação search (). A operação search () retorna o índice do elemento que está sendo procurado. Este índice é contado do topo da pilha.
Stack intStack = new Stack (); intStack.push (100); intStack.push (200); int index = inStack.search(100); //index will have the value 2.Tamanho da pilha
O tamanho do objeto Stack é dado pelo java.util.Stack.size () método. Ele retorna o número total de elementos na pilha.
O exemplo a seguir imprime o tamanho da pilha.
Stack myStack = new Stack(); myStack.push(100); myStack.push(200); myStack.push(300); System.out.println('Stack size:' + myStack.size()); //Stack size: 3 Imprimir / iterar elementos de pilha
Podemos declarar um iterador para a Pilha e então percorrer toda a Pilha usando este iterador. Desta forma, podemos visitar e imprimir cada elemento da pilha, um por um.
O programa a seguir mostra a maneira de iterar Stack usando um iterador.
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() + ' '); } } }Resultado:
Elementos da pilha:
PUNE MUMBAI NASHIK
Empilhar usando Java 8
Também podemos imprimir ou percorrer os elementos da pilha usando recursos Java 8, como APIs de fluxo, forEach e construções forEachRemaining.
O programa a seguir demonstra o uso de construções Java 8 para percorrer a pilha.
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 + ' '); }); } } Resultado:
Empilhe elementos usando Java 8 forEach:
PUNE MUMBAI NASHIK
Empilhar elementos usando Java 8 forEachRemaining:
PUNE MUMBAI NASHIK
Implementação de pilha em Java
O programa a seguir implementa a pilha detalhada demonstrando as várias operações da pilha.
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()); } } Resultado:
Pilha inicial: ()
A pilha está vazia? : verdade
Empilhar após a operação de empurrar: (10, 20, 30, 40)
Elemento exibido: 40
Pilha após operação pop: (10, 20, 30)
Elemento 10 encontrado na posição: 3
A pilha está vazia? : falso
como ver um arquivo eps
Empilhar para Array em Java
A estrutura de dados da pilha pode ser convertida em um Array usando o método ‘toArray ()’ da classe Stack.
O programa a seguir demonstra essa conversão.
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 Resultado:
O conteúdo da pilha: (PUNE, MUMBAI, NASHIK)
O conteúdo do Array:
PUNE MUMBAI NASHIK
Implementação de pilha em Java usando Array
A pilha pode ser implementada usando um Array. Todas as operações de pilha são realizadas usando uma matriz.
O programa a seguir demonstra a implementação de Stack usando uma matriz.
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(); } } Resultado:
Pilha inicial vazia: verdadeiro
Após a operação push ...
Imprimindo elementos da pilha… ..
40 30 20 10
Item estourado: 40
Item estourado: 30
Depois da operação pop ...
Imprimindo elementos da pilha… ..
20 10
Implementação de pilha usando lista vinculada
A pilha também pode ser implementada usando uma lista vinculada, assim como fizemos usando matrizes. Uma vantagem de usar uma lista vinculada para implementar a pilha é que ela pode aumentar ou diminuir dinamicamente. Não precisamos ter uma restrição de tamanho máximo como em matrizes.
O programa a seguir implementa uma lista vinculada para realizar operações de pilha.
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()); } } Resultado:
Elementos da pilha:
1-> 3-> 5-> 7-> 9->
Topo da pilha: 1
Pop dois elementos
Elementos da pilha:
5-> 7-> 9->
Novo topo da pilha: 5
perguntas frequentes
P # 1) O que são pilhas em Java?
Responda: Uma pilha é uma estrutura de dados LIFO (Último a entrar, Primeiro a sair) para armazenar elementos. Os elementos da pilha são adicionados ou removidos da pilha de uma extremidade chamada Topo da pilha.
A adição de um elemento à pilha é feita usando a operação Push. A exclusão de elementos é feita usando a operação pop. Em Java, uma pilha é implementada usando a classe Stack.
P # 2) Stack é uma coleção em Java?
como encontrar a chave de criptografia sem fio
Responda: sim. A pilha é uma coleção de legado em Java que está disponível na API de coleção em Java 1.0 em diante. Stack herda a classe Vector da interface List.
P # 3) Stack é uma interface?
Responda: Pilha de interface é uma interface que descreve a estrutura last-in, first-out e é usada para armazenar o estado de problemas recursivos.
P # 4) Para que são usadas as pilhas?
Resposta: A seguir estão as principais aplicações da pilha:
- Avaliação e conversões de expressão: Stack é usado para converter expressões em postfix, infix e prefix. Também é usado para avaliar essas expressões.
- A pilha também é usada para analisar árvores de sintaxe.
- A pilha é usada para verificar os parênteses em uma expressão.
- A pilha é usada para resolver problemas de retrocesso.
- As chamadas de função são avaliadas usando pilhas.
P # 5) Quais são as vantagens da pilha?
Responda: Variáveis armazenadas na pilha são destruídas automaticamente quando retornadas. As pilhas são uma escolha melhor quando a memória é alocada e desalocada. As pilhas também limpam a memória. Além disso, as pilhas podem ser usadas com eficácia para avaliar expressões e analisar as expressões.
Conclusão
Isso conclui nosso tutorial sobre Pilhas em Java. A classe Stack faz parte da API de coleta e oferece suporte a operações push, pop, peek e search. Os elementos são adicionados ou removidos de / para a pilha em apenas uma extremidade. Essa extremidade é chamada de topo da pilha.
Neste tutorial, vimos todos os métodos suportados pela classe stack. Também implementamos a pilha usando arrays e listas vinculadas.
Continuaremos com outras classes de coleção em nossos tutoriais subsequentes.
=> Leia a série de treinamento Easy Java
Leitura recomendada
- Tutorial de reflexão Java com exemplos
- Tutorial da classe Java Scanner com exemplos
- O que é um HashTable Java - implementação e exemplo de HashTable
- O que é Java Vector | Tutorial da classe Java Vector com exemplos
- Tutorial da classe Java Array - classe java.util.Arrays com exemplos
- Java Basics: Java Syntax, Java Class e Core Java Concepts
- LinkedHashMap em Java - Exemplo e implementação de LinkedHashMap
- Tutorial Java SWING: Container, Componentes e Manipulação de Eventos
