Como Verificar se uma Pilha em Java está Vazia - Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se uma Stack em Java está vazia. Exploraremos diferentes métodos para alcançar isso, incluindo o método padrão isEmpty() e o método size(). Você também aprenderá como lidar com o caso de uma pilha (stack) nula.

Através de exemplos práticos, você obterá experiência prática no uso dessas técnicas para determinar a vaziedade de uma Stack Java, que é uma operação fundamental ao trabalhar com esta estrutura de dados.

Usar isEmpty() para Verificação da Pilha

Nesta etapa, aprenderemos como verificar se uma Stack em Java está vazia usando o método isEmpty(). A classe Stack faz parte do Java Collections Framework e representa uma pilha (stack) de objetos last-in, first-out (LIFO). Verificar se uma pilha está vazia é uma operação comum ao trabalhar com pilhas, por exemplo, antes de tentar remover um elemento.

O método isEmpty() é uma maneira simples e eficiente de determinar se uma coleção, incluindo uma Stack, contém algum elemento. Ele retorna true se a coleção estiver vazia (não contiver elementos) e false caso contrário.

Vamos criar um programa Java simples para demonstrar o método isEmpty().

Abra o arquivo HelloJava.java no editor WebIDE, caso ele ainda não esteja aberto.

Substitua todo o conteúdo do arquivo pelo seguinte código:

import java.util.Stack;

public class HelloJava {
    public static void main(String[] args) {
        // Create a new Stack
        Stack<String> stack = new Stack<>();

        // Check if the stack is empty using isEmpty()
        boolean isEmptyBeforePush = stack.isEmpty();
        System.out.println("Is the stack empty before pushing elements? " + isEmptyBeforePush);

        // Push some elements onto the stack
        stack.push("Element 1");
        stack.push("Element 2");

        // Check if the stack is empty after pushing elements
        boolean isEmptyAfterPush = stack.isEmpty();
        System.out.println("Is the stack empty after pushing elements? " + isEmptyAfterPush);
    }
}

Vamos analisar as novas partes deste código:

import java.util.Stack;: Esta linha importa a classe Stack, tornando-a disponível para uso em nosso programa.
Stack<String> stack = new Stack<>();: Esta linha cria uma nova Stack vazia que pode conter objetos String.
stack.isEmpty();: Este é o método no qual estamos focando. Ele verifica se o objeto stack está vazio.
stack.push("...");: Este método adiciona um elemento ao topo da pilha.

Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, vamos compilar nosso programa modificado. No Terminal, certifique-se de estar no diretório ~/project. Em seguida, execute:
```
javac HelloJava.java
```
Se a compilação for bem-sucedida, você não verá nenhuma saída.
Finalmente, vamos executar nosso programa:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Is the stack empty before pushing elements? true
Is the stack empty after pushing elements? false
```
Esta saída confirma que o método isEmpty() relatou corretamente o estado da pilha antes e depois de adicionar elementos.

Verificar com o Método size()

Na etapa anterior, usamos o método isEmpty() para verificar se uma pilha (stack) está vazia. Outro método útil para coleções, incluindo Stack, é o método size(). O método size() retorna o número de elementos atualmente na coleção. Podemos usar este método para verificar se uma pilha está vazia, verificando se seu tamanho é 0.

Embora isEmpty() seja geralmente preferido para simplesmente verificar se uma coleção está vazia, pois às vezes pode ser mais eficiente, verificar se size() == 0 atinge o mesmo resultado. É bom estar ciente de ambos os métodos.

Vamos modificar nosso programa para usar o método size() para verificar a vaziedade.

Abra o arquivo HelloJava.java no editor WebIDE.

Modifique o código para usar size() == 0 em vez de isEmpty():

import java.util.Stack;

public class HelloJava {
    public static void main(String[] args) {
        // Create a new Stack
        Stack<String> stack = new Stack<>();

        // Check if the stack is empty using size()
        boolean isEmptyBeforePush = stack.size() == 0;
        System.out.println("Is the stack empty before pushing elements? " + isEmptyBeforePush);

        // Push some elements onto the stack
        stack.push("Element A");
        stack.push("Element B");
        stack.push("Element C");

        // Check the size of the stack after pushing elements
        int sizeAfterPush = stack.size();
        System.out.println("Size of the stack after pushing elements: " + sizeAfterPush);

        // Check if the stack is empty after pushing elements using size()
        boolean isEmptyAfterPush = stack.size() == 0;
        System.out.println("Is the stack empty after pushing elements? " + isEmptyAfterPush);
    }
}

Observe as mudanças:

Substituímos stack.isEmpty() por stack.size() == 0 para verificar a vaziedade.
Também adicionamos uma linha para imprimir o tamanho real da pilha após inserir elementos usando stack.size().

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac HelloJava.java
```
Novamente, nenhuma saída significa compilação bem-sucedida.
Execute o programa:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Is the stack empty before pushing elements? true
Size of the stack after pushing elements: 3
Is the stack empty after pushing elements? false
```
Esta saída mostra que a verificação stack.size() == 0 identifica corretamente uma pilha vazia, e stack.size() retorna o número de elementos.

Testar com Pilha Nula

Nas etapas anteriores, aprendemos como verificar se uma Stack está vazia usando isEmpty() e size(). Também é importante entender o que acontece se o próprio objeto Stack for null. Em Java, null significa que uma variável não se refere a nenhum objeto. Tentar chamar um método em um objeto null resultará em uma NullPointerException, que é um erro comum em tempo de execução.

Vamos ver isso em ação e aprender como lidar com isso.

Abra o arquivo HelloJava.java no editor WebIDE.

Modifique o código para definir a pilha como null e, em seguida, tentar verificar se ela está vazia:

import java.util.Stack;

public class HelloJava {
    public static void main(String[] args) {
        // Create a new Stack and then set it to null
        Stack<String> stack = new Stack<>();
        stack.push("Some Element"); // Add an element first
        stack = null; // Now set the stack variable to null

        // Try to check if the stack is empty using isEmpty()
        try {
            boolean isEmpty = stack.isEmpty(); // This line will cause an error
            System.out.println("Is the stack empty? " + isEmpty);
        } catch (NullPointerException e) {
            System.out.println("Caught a NullPointerException! The stack object is null.");
        }

        // Try to check the size using size()
        try {
             int size = stack.size(); // This line will also cause an error
             System.out.println("Size of the stack: " + size);
        } catch (NullPointerException e) {
             System.out.println("Caught a NullPointerException! Cannot get size of a null stack.");
        }
    }
}

Aqui está o que é novo:

stack = null;: Esta linha faz com que a variável stack aponte para null. O objeto Stack que criamos anteriormente não é mais acessível através desta variável.
try { ... } catch (NullPointerException e) { ... }: Este é um bloco try-catch. Ele é usado para lidar com erros potenciais (exceções) que podem ocorrer durante a execução do código dentro do bloco try. Se uma NullPointerException ocorrer, o código dentro do bloco catch será executado.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
A compilação deve ser bem-sucedida.
Execute o programa:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Caught a NullPointerException! The stack object is null.
Caught a NullPointerException! Cannot get size of a null stack.
```
Esta saída mostra que tentar chamar isEmpty() ou size() em uma variável de pilha null resulta em uma NullPointerException, e nossos blocos try-catch lidaram com sucesso com essas exceções.

Isso demonstra por que é crucial garantir que um objeto não seja null antes de chamar métodos nele. Você pode verificar se um objeto é null usando uma condição simples: if (stack != null) { ... }.

Resumo

Neste laboratório, aprendemos como verificar se uma Stack em Java está vazia. Exploramos o método principal para esse fim, isEmpty(), que faz parte do Java Collections Framework. Vimos como usar isEmpty() para determinar se uma pilha contém algum elemento, retornando true para uma pilha vazia e false caso contrário.

Demonstramos o uso de isEmpty() criando uma nova Stack, verificando seu status de vazio antes e depois de inserir elementos (pushing), e imprimindo os resultados. Este exercício prático solidificou nossa compreensão de como usar efetivamente o método isEmpty() para verificações de vaziedade de pilhas em programas Java.

Como Verificar se uma Pilha (Stack) está Vazia em Java

Introdução

Usar isEmpty() para Verificação da Pilha

Verificar com o Método size()

Testar com Pilha Nula

Resumo