Pilha em Java

As pilhas são uma das estruturas de dados fundamentais em ciência da computação, amplamente utilizadas em algoritmos e na manipulação de dados. Em Java, a classe Stack representa uma pilha, oferecendo uma maneira simples e eficiente de armazenar dados em uma ordem específica. Neste post, vamos explorar o que é uma pilha, como funciona e como você pode implementá-la em Java.

Principais operações em uma Pilha

As operações básicas que podem ser realizadas em uma pilha são:

1. push(): Adiciona um elemento ao topo da pilha.
2. pop(): Remove e retorna o elemento do topo da pilha.
3. peek(): Retorna o elemento do topo da pilha sem removê-lo.
4. isEmpty(): Verifica se a pilha está vazia.
5. size(): Retorna o número de elementos na pilha.

Importando a classe Stack

Para utilizar a classe Stack em seu código Java, você deve importá-la da seguinte maneira:

import java.util.Stack;

Criando e manipulando uma Pilha

A seguir, apresentamos um exemplo básico que ilustra como criar e manipular uma pilha em Java:

import java.util.Stack;

public class ExemploPilha {
    public static void main(String[] args) {
        // Criando uma pilha
        Stack<Integer> pilha = new Stack<>();

        // Adicionando elementos à pilha
        pilha.push(10);
        pilha.push(20);
        pilha.push(30);

        // Exibindo o tamanho da pilha
        System.out.println("Tamanho da pilha: " + pilha.size()); // Saída: 3

        // Acessando o elemento do topo da pilha
        System.out.println("Elemento do topo: " + pilha.peek()); // Saída: 30

        // Removendo o elemento do topo
        System.out.println("Elemento removido: " + pilha.pop()); // Saída: 30

        // Verificando o tamanho da pilha após remoção
        System.out.println("Tamanho da pilha após remoção: " + pilha.size()); // Saída: 2

        // Verificando se a pilha está vazia
        System.out.println("A pilha está vazia? " + pilha.isEmpty()); // Saída: false
    }
}

Exemplos de aplicações de Pilhas

As pilhas são utilizadas em várias aplicações, incluindo:

1. Navegação em navegadores: Os navegadores da web usam pilhas para manter o histórico de páginas visitadas. O botão “Voltar” retira a última página acessada da pilha;
   
   
2. Recursão: Durante chamadas de função recursivas, o estado das funções é armazenado em uma pilha. Quando uma função termina, o controle retorna para a função anterior que está no topo da pilha;
   
   
3. Expressões matemáticas: As pilhas são frequentemente utilizadas para avaliar expressões aritméticas e converter notações (como infixa para pós-fixa);
   
   
4. Desfazer operações em editores: A funcionalidade de “desfazer” em editores de texto é frequentemente implementada com pilhas, onde cada ação é armazenada na pilha e pode ser revertida.

Outro exemplo prático

A pilha em Java é uma das estruturas de dados e trabalha com o formato LIFO (o último a entrar é o primeiro a sair, “Last In, First Out”, em inglês).

Lembre-se da pilha como uma pilha de livros, em que o primeiro livro que foi inserido na pilha, normalmente é o último que sai dela, enquanto o último adicionado é o primeiro a ser retirado:

public class Pilha {
    
 public Object[] pilha;
 public int posicaoPilha;

 public Pilha() {

    this.posicaoPilha = -1; // indica que está nula, vazia
    this.pilha = new Object[1000]; // criando uma pilha com 1000 posições
    }
    public boolean pilhaVazia() { //isEmpty         
        if (this.posicaoPilha == -1) { //se posição for nula (-1)...
            return true;
        }
        return false;
    }
    public int tamanho() { //is        
        if (this.pilhaVazia()) { //se estiver nula...
            return 0;
        }
        return this.posicaoPilha + 1; //senão, retorna o tamanho da pilhao
    }
    public Object exibeUltimoValor() { //top        
        if (this.pilhaVazia()) { //se nula...
            return null;
        }
        return this.pilha[this.posicaoPilha];
    }
    public Object desempilhar() { //pop        
        if (pilhaVazia()) { //se nula (vazia)...
            return null;
        }
        return this.pilha[this.posicaoPilha--]; //decrementa do tam. pilha
    }
    public void empilhar(Object valor) { // push        
        if (this.posicaoPilha < this.pilha.length - 1) {
            this.pilha[++posicaoPilha] = valor;
        }
    }

    public static void main(String args[]) {
        Pilha p = new Pilha();
        p.empilhar("Portuguesa ");
        p.empilhar("Frango com catupiry ");
        p.empilhar("Calabresa ");
        p.empilhar("Quatro queijos ");
        p.empilhar(10);
                while (p.pilhaVazia() == false) {
            System.out.println(p.desempilhar());
        }
    }
 } 

As pilhas são uma estrutura de dados poderosa e versátil, amplamente utilizada em diversos algoritmos e aplicações em programação.

Com a classe Stack em Java, você pode facilmente implementar e manipular pilhas em seus projetos. Compreender como as pilhas funcionam e quando usá-las é uma habilidade essencial para qualquer desenvolvedor.

Ao longo de sua jornada de programação, você descobrirá que as pilhas são uma ferramenta indispensável para resolver muitos problemas computacionais de maneira eficiente.

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: pilha