TechCodeview

O pilha é uma estrutura de dados linear usada para armazenar a coleção de objetos. É baseado em Ultimo a entrar primeiro a sair (LIFO). Coleção Java framework fornece muitas interfaces e classes para armazenar a coleção de objetos. Um deles é o Classe de pilha que fornece diferentes operações, como push, pop, search, etc.

Nesta seção, discutiremos o Classe Java Stack , isso é métodos, e implemento a estrutura de dados da pilha em um Programa Java . Mas antes de passar para a classe Java Stack, tenha uma visão rápida de como a pilha funciona.

A estrutura de dados da pilha possui as duas operações mais importantes que são empurrar e pop . A operação push insere um elemento na pilha e a operação pop remove um elemento do topo da pilha. Vamos ver como eles funcionam na pilha.

Vamos colocar 20, 13, 89, 90, 11, 45, 18, respectivamente, na pilha.

Vamos remover (pop) 18, 45 e 11 da pilha.

Pilha vazia: Se a pilha não tiver nenhum elemento é conhecido como pilha vazia . Quando a pilha está vazia, o valor da variável superior é -1.

Quando colocamos um elemento na pilha, o topo é aumentou em 1 . Na figura a seguir,

string java.formato

• Empurre 12, topo = 0
• Empurre 6, topo = 1
• Empurre 9, topo = 2

Quando retiramos um elemento da pilha, o valor de top é diminuiu em 1 . Na figura a seguir, exibimos 9.

A tabela a seguir mostra os diferentes valores do topo.

Classe de pilha Java

Em Java, Pilha é uma classe que se enquadra na estrutura Collection que estende o Vetor aula. Ele também implementa interfaces Lista, coleção, iterável, clonável, serializável. Ele representa a pilha de objetos LIFO. Antes de usar a classe Stack, devemos importar ojava.utilpacote. A classe de pilha organizada na hierarquia da estrutura de Coleções, conforme mostrado abaixo.

Construtor de classe de pilha

A classe Stack contém apenas o construtor padrão isso cria uma pilha vazia.

 public Stack() 

Criando uma pilha

Se quisermos criar uma pilha, primeiro importe ojava.utilpacote e crie um objeto da classe Stack.

 Stack stk = new Stack(); 

Ou

 Stack stk = new Stack(); 

Onde type denota o tipo de pilha como Integer, String, etc.

Métodos da classe Stack

Podemos realizar operações push, pop, peek e search na pilha. A classe Java Stack fornece principalmente cinco métodos para realizar essas operações. Junto com isso, também fornece todos os métodos do Classe de vetor Java .

Método Stack Class vazia()

O vazio() método da classe Stack verifica se a pilha está vazia ou não. Se a pilha estiver vazia, ela retornará verdadeiro, caso contrário, retornará falso. Também podemos usar o método isEmpty() da classe Vector.

Sintaxe

 public boolean empty() 

Retorna: O método retorna verdadeiro se a pilha estiver vazia, caso contrário retorna falso.

No exemplo a seguir, criamos uma instância da classe Stack. Depois disso, invocamos o método vazio() duas vezes. A primeira vez que ele retorna verdadeiro porque não colocamos nenhum elemento na pilha. Depois disso, colocamos os elementos na pilha. Novamente invocamos o método vazio() que retorna falso porque a pilha não está vazia.

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); } } 

Saída:

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

Método push() da classe de pilha

O método insere um item no topo da pilha. Funciona da mesma forma que o método addElement(item) da classe Vector. Ele passa um parâmetro item para ser empurrado para a pilha.

Sintaxe

 public E push(E item) 

Parâmetro: Um item a ser colocado no topo da pilha.

Retorna: O método retorna o argumento que passamos como parâmetro.

Método pop() da classe de pilha

O método remove um objeto do topo da pilha e retorna o mesmo objeto. Isso joga VazioStackException se a pilha estiver vazia.

Sintaxe

converter int em string em java

 public E pop() 

Retorna: Ele retorna um objeto que está no topo da pilha.

Vamos implementar a pilha em um programa Java e realizar operações 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); } } 

Saída:

 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] 

Método Stack Class peek()

Ele analisa o elemento que está no topo da pilha. Também joga VazioStackException se a pilha estiver vazia.

Sintaxe

 public E peek() 

Retorna: Ele retorna os elementos superiores da pilha.

Vamos ver um exemplo do método peek().

StackPeekMethodExample.java

 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); } } 

Saída:

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

Método search() da classe de pilha

O método pesquisa o objeto na pilha de cima para baixo. Ele analisa um parâmetro que queremos pesquisar. Ele retorna a localização baseada em 1 do objeto na pilha. O objeto mais alto da pilha é considerado à distância 1.

Suponha que o seja um objeto na pilha que queremos procurar. O método retorna a distância do topo da pilha da ocorrência mais próxima do topo da pilha. Ele usa é igual a() método para pesquisar um objeto na pilha.

Sintaxe

 public int search(Object o) 

Parâmetro: o é o objeto desejado a ser pesquisado.

Retorna: Ele retorna a localização do objeto no topo da pilha. Se retornar -1, significa que o objeto não está na pilha.

Vamos ver um exemplo do método search().

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); } } 

Operações de pilha Java

Tamanho da pilha

Também podemos encontrar o tamanho da pilha usando o método size() da classe Vector. Retorna o número total de elementos (tamanho da pilha) na pilha.

Sintaxe

 public int size() 

Vejamos um exemplo do método size() da 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); } } 

Saída:

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

Iterar elementos

Iterar significa buscar os elementos da pilha. Podemos buscar elementos da pilha usando três métodos diferentes:

• Usando iterador() Método
• Usando para cada() Método
• Usando listIterator() Método

Usando o método iterator()

É o método da interface do Iterator. Ele retorna um iterador sobre os elementos da pilha. Antes de usar o método iterator() importe ojava.util.Iteratorpacote.

Sintaxe

 Iterator iterator() 

Vamos realizar uma iteração na pilha.

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); } } } 

Saída:

 BMW Audi Ferrari Bugatti Jaguar 

Usando o método forEach()

Java fornece um método forEach() para iterar sobre os elementos. O método é definido no Iterável e Fluxo interface.

java faça enquanto

Sintaxe

 default void forEach(Consumeraction) 

Vamos iterar na pilha usando o método 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); }); } } 

Saída:

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

Usando o método listIterator()

Este método retorna um iterador de lista sobre os elementos da lista mencionada (em sequência), começando na posição especificada na lista. Ele itera a pilha de cima para baixo.

Sintaxe

 ListIterator listIterator(int index) 

Parâmetro: O método analisa um parâmetro chamado índice.

Retorna: Este método retorna um iterador de lista sobre os elementos, em sequência.

Exceção: Isso joga IndexOutOfBoundsException se o índice estiver fora do intervalo.

Vamos iterar na pilha usando o método 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); } } } 

Saída:

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