Como Verificar se um Map Está Vazio em Java

Introdução

Neste laboratório, você aprenderá como verificar se um Map em Java está vazio. Exploraremos diferentes métodos para esta operação comum, começando com o método direto isEmpty(). Você também aprenderá como verificar o tamanho de um mapa usando o método size() e, o mais importante, como lidar com casos em que o próprio mapa pode ser nulo para evitar potenciais erros NullPointerException. Ao final deste laboratório, você estará proficiente em determinar a condição de vazio de Mapas Java em vários cenários.

Usar isEmpty() para Verificação de Map

Nesta etapa, aprenderemos como verificar se um Map em Java está vazio usando o método isEmpty(). Um Map é uma coleção de pares chave-valor, e verificar se ele está vazio é uma operação comum.

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

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

import java.util.HashMap;
import java.util.Map;

public class MapCheck {

    public static void main(String[] args) {
        // Create an empty Map
        Map<String, Integer> emptyMap = new HashMap<>();

        // Check if the map is empty using isEmpty()
        boolean isEmpty = emptyMap.isEmpty();

        // Print the result
        System.out.println("Is the map empty? " + isEmpty);

        // Create a non-empty Map
        Map<String, Integer> nonEmptyMap = new HashMap<>();
        nonEmptyMap.put("one", 1);
        nonEmptyMap.put("two", 2);

        // Check if the non-empty map is empty
        boolean isNonEmpty = nonEmptyMap.isEmpty();

        // Print the result
        System.out.println("Is the non-empty map empty? " + isNonEmpty);
    }
}

Vamos detalhar o código:

• import java.util.HashMap; e import java.util.Map;: Estas linhas importam as classes necessárias para trabalhar com Maps.
• Map<String, Integer> emptyMap = new HashMap<>();: Isso cria um novo HashMap vazio. HashMap é uma implementação comum da interface Map. Especificamos que as chaves serão String e os valores serão Integer.
• boolean isEmpty = emptyMap.isEmpty();: É aqui que usamos o método isEmpty(). Ele retorna true se o mapa não contiver mapeamentos chave-valor e false caso contrário. O resultado é armazenado em uma variável booleana isEmpty.
• System.out.println("Is the map empty? " + isEmpty);: Isso imprime o resultado da verificação no console.
• O código então repete o processo com um nonEmptyMap para mostrar como isEmpty() funciona quando o mapa não está vazio.

Salve o arquivo MapCheck.java (Ctrl+S ou Cmd+S).

Agora, abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project.

Compile o código Java usando o comando javac:

javac MapCheck.java

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

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

java MapCheck

Você deve ver a seguinte saída:

Is the map empty? true
Is the non-empty map empty? false

Esta saída confirma que isEmpty() identificou corretamente o mapa vazio e o mapa não vazio. Usar isEmpty() é a maneira recomendada de verificar se um mapa está vazio, pois é claro e eficiente.

Verificar o Tamanho do Map com size()

Nesta etapa, aprenderemos como obter o número de mapeamentos chave-valor em um Map usando o método size(). Isso é útil quando você precisa saber quantos elementos estão atualmente armazenados no mapa.

Continuaremos trabalhando com o arquivo MapCheck.java que criamos na etapa anterior. Abra MapCheck.java no editor WebIDE.

Agora, vamos modificar o método main para incluir a verificação do tamanho dos mapas. Substitua o código existente no método main pelo seguinte:

import java.util.HashMap;
import java.util.Map;

public class MapCheck {

    public static void main(String[] args) {
        // Create an empty Map
        Map<String, Integer> emptyMap = new HashMap<>();

        // Check the size of the empty map using size()
        int emptySize = emptyMap.size();

        // Print the result
        System.out.println("Size of the empty map: " + emptySize);

        // Create a non-empty Map
        Map<String, Integer> nonEmptyMap = new HashMap<>();
        nonEmptyMap.put("one", 1);
        nonEmptyMap.put("two", 2);
        nonEmptyMap.put("three", 3); // Add one more element

        // Check the size of the non-empty map
        int nonEmptySize = nonEmptyMap.size();

        // Print the result
        System.out.println("Size of the non-empty map: " + nonEmptySize);
    }
}

Vamos analisar as mudanças:

• int emptySize = emptyMap.size();: Esta linha chama o método size() no emptyMap. O método size() retorna o número de pares chave-valor no mapa como um inteiro. O resultado é armazenado em uma variável inteira emptySize.
• System.out.println("Size of the empty map: " + emptySize);: Isso imprime o tamanho do mapa vazio.
• Também adicionamos um elemento extra ("three", 3) ao nonEmptyMap para mostrar como o tamanho muda.
• int nonEmptySize = nonEmptyMap.size();: Isso chama size() no nonEmptyMap para obter seu tamanho.
• System.out.println("Size of the non-empty map: " + nonEmptySize);: Isso imprime o tamanho do mapa não vazio.

Salve o arquivo MapCheck.java (Ctrl+S ou Cmd+S).

Agora, abra o Terminal e certifique-se de estar no diretório ~/project.

Compile o código Java modificado:

javac MapCheck.java

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

java MapCheck

Você deve ver a seguinte saída:

Size of the empty map: 0
Size of the non-empty map: 3

Esta saída mostra que size() relatou corretamente o número de elementos em ambos os mapas, o vazio e o não vazio. O método size() é uma maneira simples e eficaz de determinar o número atual de entradas em um Map Java.

Lidar com Maps Nulos

Nas etapas anteriores, trabalhamos com mapas que estavam vazios ou continham elementos. No entanto, é importante considerar o que acontece se uma variável Map for 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 um mapa null resultará em um NullPointerException, que é um erro comum em Java.

Nesta etapa, aprenderemos como lidar com referências de mapa null em potencial com segurança antes de tentar verificar sua vazia ou tamanho.

Abra o arquivo MapCheck.java no editor WebIDE novamente.

Vamos adicionar código para demonstrar e lidar com um mapa null. Modifique o método main para incluir o seguinte:

import java.util.HashMap;
import java.util.Map;

public class MapCheck {

    public static void main(String[] args) {
        // Create an empty Map
        Map<String, Integer> emptyMap = new HashMap<>();

        // Check the size of the empty map using size()
        int emptySize = emptyMap.size();

        // Print the result
        System.out.println("Size of the empty map: " + emptySize);

        // Create a non-empty Map
        Map<String, Integer> nonEmptyMap = new HashMap<>();
        nonEmptyMap.put("one", 1);
        nonEmptyMap.put("two", 2);
        nonEmptyMap.put("three", 3); // Add one more element

        // Check the size of the non-empty map
        int nonEmptySize = nonEmptyMap.size();

        // Print the result
        System.out.println("Size of the non-empty map: " + nonEmptySize);

        // Declare a Map variable but don't initialize it (it will be null)
        Map<String, Integer> nullMap = null;

        // --- Handling the null map ---

        // Check if the map is null before calling methods
        if (nullMap == null) {
            System.out.println("The nullMap is null.");
        } else {
            // This block will not be executed for nullMap
            System.out.println("Is the nullMap empty? " + nullMap.isEmpty());
            System.out.println("Size of the nullMap: " + nullMap.size());
        }

        // A safer way to check if a map is empty (handles null)
        boolean isNullMapEmpty = (nullMap == null || nullMap.isEmpty());
        System.out.println("Is the nullMap considered empty (including null)? " + isNullMapEmpty);

        // A safer way to get the size (handles null)
        int nullMapSize = (nullMap == null) ? 0 : nullMap.size();
        System.out.println("Size of the nullMap (handling null): " + nullMapSize);
    }
}

Aqui está o que adicionamos:

• Map<String, Integer> nullMap = null;: Isso declara uma variável Map, mas a define explicitamente como null.
• if (nullMap == null) { ... }: Esta é a parte crucial para lidar com null. Verificamos se a variável nullMap é null antes de tentar chamar qualquer método nela. Se for null, imprimimos uma mensagem. Se não fosse null, o bloco else seria executado, e poderíamos chamar com segurança isEmpty() e size().
• boolean isNullMapEmpty = (nullMap == null || nullMap.isEmpty());: Este é um padrão comum para verificar se um mapa está efetivamente "vazio", o que inclui o caso em que a própria referência do mapa é null. O operador || (OR) significa que se nullMap == null for verdadeiro, toda a expressão é verdadeira, e nullMap.isEmpty() nem é avaliado, impedindo o NullPointerException.
• int nullMapSize = (nullMap == null) ? 0 : nullMap.size();: Isso usa o operador ternário (? :) para obter o tamanho com segurança. Se nullMap for null, a expressão é avaliada como 0. Caso contrário, ela é avaliada como nullMap.size().

Salve o arquivo MapCheck.java (Ctrl+S ou Cmd+S).

Compile o código modificado no Terminal:

javac MapCheck.java

Execute o programa:

java MapCheck

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

Size of the empty map: 0
Size of the non-empty map: 3
The nullMap is null.
Is the nullMap considered empty (including null)? true
Size of the nullMap (handling null): 0

Observe que as linhas dentro do bloco else para nullMap não foram executadas, e verificamos com sucesso se o nullMap era nulo e obtivemos seu tamanho (tratando nulo como tamanho 0) sem causar um erro.

Lidar com referências null é muito importante em Java para evitar NullPointerExceptions e tornar seus programas mais robustos. Sempre considere se uma variável pode ser null antes de chamar métodos nela.

Resumo

Neste laboratório, aprendemos como verificar se um Map em Java está vazio. Exploramos o método principal para isso, isEmpty(), que indica diretamente se um mapa contém quaisquer pares chave-valor. Vimos como aplicar este método tanto a mapas vazios recém-criados quanto a mapas que foram preenchidos com dados, demonstrando seu uso direto e o resultado booleano que ele retorna.

Além da verificação básica isEmpty(), também abordamos métodos alternativos, como usar size() para determinar se o tamanho de um mapa é zero, o que é funcionalmente equivalente a verificar a sua vazia. Além disso, abordamos o aspecto crucial de lidar com potenciais referências de mapa null para evitar NullPointerExceptions, enfatizando a importância das verificações de nulo antes de tentar chamar métodos em um objeto mapa.