Como Verificar se uma Lista Está Vazia em Java

Introdução

Neste laboratório, você aprenderá como verificar efetivamente se uma lista em Java está vazia. Exploraremos o método padrão isEmpty(), verificaremos o tamanho da lista usando size(), e entenderemos como lidar com cenários potenciais de listas nulas para escrever código robusto e confiável.

Usar isEmpty() para Verificação da Lista

Nesta etapa, aprenderemos como verificar se uma lista em Java está vazia usando o método isEmpty(). Esta é uma tarefa comum em programação, e isEmpty() fornece uma maneira clara e eficiente de fazê-lo.

Primeiro, vamos criar um novo arquivo Java chamado ListCheck.java no seu diretório ~/project. Você pode fazer isso clicando com o botão direito no Explorador de Arquivos à esquerda e selecionando "Novo Arquivo", em seguida, digitando ListCheck.java.

Agora, abra ListCheck.java no editor e adicione o seguinte código:

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());
    }
}

Vamos analisar este código:

• import java.util.ArrayList; e import java.util.List;: Estas linhas importam as classes necessárias para trabalhar com listas.
• List<String> emptyList = new ArrayList<>();: Esta linha cria uma nova lista vazia que pode conter objetos String.
• List<String> populatedList = new ArrayList<>();: Esta linha cria outra nova lista.
• populatedList.add("Apple"); e populatedList.add("Banana");: Estas linhas adicionam elementos à populatedList.
• System.out.println("Is emptyList empty? " + emptyList.isEmpty());: Esta linha chama o método isEmpty() na emptyList. O método isEmpty() retorna true se a lista não tiver elementos e false caso contrário. O resultado é então impresso no console.
• System.out.println("Is populatedList empty? " + populatedList.isEmpty());: Esta linha faz o mesmo para populatedList.

Salve o arquivo ListCheck.java.

Agora, abra o Terminal na parte inferior da WebIDE e certifique-se de que você está no diretório ~/project. Você pode usar o comando cd ~/project se necessário.

Compile o código Java usando o comando javac:

javac ListCheck.java

Se não houver erros, um arquivo ListCheck.class será criado no diretório ~/project.

Finalmente, execute o programa Java compilado usando o comando java:

java ListCheck

Você deve ver uma saída semelhante a esta:

Is emptyList empty? true
Is populatedList empty? false

Esta saída confirma que isEmpty() identificou corretamente a lista vazia e a lista com elementos. Usar isEmpty() é a maneira preferida de verificar uma lista vazia em Java, pois é mais legível e potencialmente mais eficiente do que verificar o tamanho.

Verificar o Tamanho da Lista com size()

Na etapa anterior, aprendemos como verificar se uma lista está vazia usando isEmpty(). Embora isEmpty() seja ótimo para verificar se uma lista tem algum elemento, às vezes você precisa saber exatamente quantos elementos estão em uma lista. Para isso, Java fornece o método size().

Nesta etapa, modificaremos nosso arquivo ListCheck.java para usar o método size() e ver como ele funciona.

Abra o arquivo ListCheck.java no editor WebIDE, caso ainda não esteja aberto. Ele deve estar localizado no seu diretório ~/project.

Agora, vamos adicionar algumas linhas ao nosso método main para imprimir o tamanho de nossas listas. Adicione as seguintes linhas após as linhas onde você usou isEmpty():

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());

        // Get and print the size of the lists using size()
        System.out.println("Size of emptyList: " + emptyList.size());
        System.out.println("Size of populatedList: " + populatedList.size());
    }
}

Adicionamos duas novas linhas:

• System.out.println("Size of emptyList: " + emptyList.size());: Esta linha chama o método size() na emptyList. O método size() retorna o número de elementos na lista como um inteiro.
• System.out.println("Size of populatedList: " + populatedList.size());: Esta linha faz o mesmo para populatedList.

Salve o arquivo ListCheck.java.

Agora, volte para o Terminal no diretório ~/project. Precisamos recompilar o código Java modificado:

javac ListCheck.java

Se a compilação for bem-sucedida, execute o programa novamente:

java ListCheck

Você deve agora ver uma saída semelhante a esta:

Is emptyList empty? true
Is populatedList empty? false
Size of emptyList: 0
Size of populatedList: 2

Como você pode ver, size() relatou corretamente que emptyList tem 0 elementos e populatedList tem 2 elementos.

Embora você pudesse verificar se uma lista está vazia verificando se seu tamanho é 0 (list.size() == 0), usar isEmpty() é geralmente preferível por clareza e legibilidade. No entanto, size() é essencial quando você precisa saber o número exato de elementos em uma lista, por exemplo, ao iterar pela lista ou realizar cálculos com base no número de itens.

Lidar com Listas Nulas

Nas etapas anteriores, trabalhamos com listas que estavam vazias ou continham elementos. No entanto, na programação do mundo real, é possível que uma variável de lista seja null. Uma referência null significa que a variável não aponta para nenhum objeto na memória. Tentar chamar um método como isEmpty() ou size() em uma lista null resultará em uma NullPointerException, que é um erro comum em Java.

Nesta etapa, aprenderemos como lidar com segurança com listas null antes de tentar verificar se estão vazias ou obter seu tamanho.

Abra o arquivo ListCheck.java no editor WebIDE.

Vamos adicionar uma nova variável de lista e defini-la como null. Em seguida, demonstraremos o que acontece quando você tenta chamar métodos nela sem verificar se é null. Modifique seu método main para incluir o seguinte código:

import java.util.ArrayList;
import java.util.List;

public class ListCheck {

    public static void main(String[] args) {
        // Create an empty list
        List<String> emptyList = new ArrayList<>();

        // Create a list with elements
        List<String> populatedList = new ArrayList<>();
        populatedList.add("Apple");
        populatedList.add("Banana");

        // Create a null list
        List<String> nullList = null;

        // Check if the lists are empty using isEmpty()
        System.out.println("Is emptyList empty? " + emptyList.isEmpty());
        System.out.println("Is populatedList empty? " + populatedList.isEmpty());

        // Get and print the size of the lists using size()
        System.out.println("Size of emptyList: " + emptyList.size());
        System.out.println("Size of populatedList: " + populatedList.size());

        // --- This part will cause an error if uncommented ---
        // System.out.println("Is nullList empty? " + nullList.isEmpty()); // This line will cause a NullPointerException
        // System.out.println("Size of nullList: " + nullList.size());   // This line will also cause a NullPointerException
        // ----------------------------------------------------

        // Safely check for null before calling methods
        System.out.println("\nSafely checking for null:");
        if (nullList == null) {
            System.out.println("nullList is null.");
        } else {
            System.out.println("Is nullList empty? " + nullList.isEmpty());
            System.out.println("Size of nullList: " + nullList.size());
        }

        if (emptyList == null) {
             System.out.println("emptyList is null.");
        } else {
             System.out.println("Is emptyList empty? " + emptyList.isEmpty());
             System.out.println("Size of emptyList: " + emptyList.size());
        }
    }
}

Adicionamos:

• List<String> nullList = null;: Isso declara uma variável de lista, mas define seu valor como null.
• Linhas comentadas que causariam uma NullPointerException.
• Uma instrução if: if (nullList == null). Esta é a parte crucial para lidar com null. Verificamos se a variável nullList é null antes de tentar chamar qualquer método nela. Se for null, imprimimos uma mensagem. Se não for null, podemos chamar com segurança isEmpty() e size().
• Também adicionamos uma verificação semelhante para emptyList para mostrar que a condição if funciona corretamente também para listas não nulas.

Salve o arquivo ListCheck.java.

Compile o código modificado no Terminal:

javac ListCheck.java

Execute o programa:

java ListCheck

A saída deve ser semelhante a esta:

Is emptyList empty? true
Is populatedList empty? false
Size of emptyList: 0
Size of populatedList: 2

Safely checking for null:
nullList is null.
Is emptyList empty? true
Size of emptyList: 0

Observe que verificamos com sucesso se nullList era null e evitamos a NullPointerException. Também confirmamos que a verificação funciona corretamente para emptyList.

Lembre-se sempre de verificar se uma lista (ou qualquer referência de objeto) pode ser null antes de chamar métodos nela. Esta é uma prática fundamental em Java para evitar erros de NullPointerException. Um padrão comum é if (myList != null && !myList.isEmpty()) para verificar se uma lista não é nula e não está vazia em uma condição.

Resumo

Neste laboratório, aprendemos como verificar se uma lista em Java está vazia. Começamos explorando o método isEmpty(), que fornece uma maneira direta e eficiente de determinar se uma lista contém algum elemento. Criamos listas de exemplo, tanto vazias quanto preenchidas, e usamos isEmpty() para verificar seu estado, observando a saída booleana.

Também examinamos como usar o método size() para verificar se uma lista está vazia, comparando seu tamanho a zero. Este método retorna o número de elementos na lista, e um tamanho de 0 indica uma lista vazia. Finalmente, abordamos o aspecto crucial de lidar com listas nulas antes de tentar verificar se estão vazias, demonstrando como prevenir NullPointerException adicionando uma verificação nula.