LabEx
EntrarJunte-se

Como Verificar se um Array Contém Elementos Nulos em Java

JavaBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como verificar se um array Java contém elementos nulos. O tratamento de valores nulos é uma habilidade fundamental na programação Java para prevenir erros comuns como NullPointerException. Exploraremos três métodos diferentes para alcançar isso: iterando pelo array usando um loop, aproveitando o poder da Stream API e contando o número de elementos nulos presentes no array. Ao final deste laboratório, você estará equipado com técnicas práticas para identificar e gerenciar efetivamente valores nulos dentro de seus arrays Java.

Looping pelo Array para Verificação de Nulos

Nesta etapa, aprenderemos como verificar valores null em um array Java, iterando por seus elementos. O tratamento de valores null é crucial em Java para prevenir NullPointerExceptions, que são erros comuns.

Um valor null em Java significa que uma variável não se refere a nenhum objeto. Quando você tenta acessar um método ou um campo de uma variável que é null, ocorre uma NullPointerException, fazendo com que seu programa trave.

Vamos criar um programa Java simples para demonstrar como iterar por um array e verificar elementos null.

  1. Abra o arquivo HelloJava.java no editor WebIDE. Se você não o tiver aberto, pode encontrá-lo no File Explorer à esquerda, dentro da pasta project.

  2. Substitua o código existente em HelloJava.java pelo seguinte código:

    public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[5]; // Declare an array of Strings with size 5
        names[0] = "Alice";
        names[1] = "Bob";
        names[2] = null; // Assign a null value
        names[3] = "Charlie";
        names[4] = null; // Assign another null value

        System.out.println("Checking array for null values:");

        // Loop through the array
        for (int i = 0; i < names.length; i++) {
            // Check if the current element is null
            if (names[i] == null) {
                System.out.println("Element at index " + i + " is null.");
            } else {
                System.out.println("Element at index " + i + " is: " + names[i]);
            }
        }
    }
}

    Vamos analisar as novas partes deste código:

    • String[] names = new String[5];: Esta linha declara um array chamado names que pode conter 5 objetos String. Quando você cria um array de objetos como este, os elementos são automaticamente inicializados como null.
    • names[2] = null; e names[4] = null;: Estamos explicitamente atribuindo null aos elementos nos índices 2 e 4.
    • for (int i = 0; i < names.length; i++): Este é um loop for padrão que itera pelo array do primeiro elemento (índice 0) ao último elemento (names.length - 1).
    • if (names[i] == null): Dentro do loop, esta instrução if verifica se o elemento no índice atual i é igual a null.
    • System.out.println("Element at index " + i + " is null.");: Se o elemento for null, esta linha é executada.
    • System.out.println("Element at index " + i + " is: " + names[i]);: Se o elemento não for null, esta linha é executada, imprimindo o valor do elemento.

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

  4. Agora, compile o programa modificado. Abra o Terminal na parte inferior do WebIDE e execute o seguinte comando:

    javac HelloJava.java

    Se não houver erros, a compilação foi bem-sucedida.

  5. Finalmente, execute o programa compilado:

    java HelloJava

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

    Checking array for null values:
Element at index 0 is: Alice
Element at index 1 is: Bob
Element at index 2 is null.
Element at index 3 is: Charlie
Element at index 4 is null.

    Esta saída mostra que nosso programa identificou e relatou com sucesso os elementos null no array.

Nesta etapa, você aprendeu como iterar manualmente por um array Java e verificar cada elemento em busca de um valor null usando uma simples condição if. Esta é uma técnica fundamental para lidar com potenciais NullPointerExceptions.

Usar a Stream API para Detectar Nulos

Na etapa anterior, usamos um loop for tradicional para verificar valores null em um array. O Java 8 introduziu a Stream API, que fornece uma maneira mais funcional e, muitas vezes, mais concisa de processar coleções de dados, incluindo arrays. Nesta etapa, aprenderemos como usar a Stream API para detectar elementos null.

A Stream API permite que você execute operações em uma sequência de elementos de forma declarativa. Isso significa que você descreve o que deseja fazer, em vez de como fazê-lo (como com um loop for).

Vamos modificar nosso programa HelloJava.java para usar a Stream API para encontrar e imprimir os elementos null.

  1. Abra o arquivo HelloJava.java no editor WebIDE.

  2. Substitua o código existente pelo seguinte:

    import java.util.Arrays; // Import the Arrays class
import java.util.Objects; // Import the Objects class

public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[5];
        names[0] = "Alice";
        names[1] = "Bob";
        names[2] = null;
        names[3] = "Charlie";
        names[4] = null;

        System.out.println("Checking array for null values using Stream API:");

        // Convert the array to a Stream
        Arrays.stream(names)
              // Filter for null elements
              .filter(Objects::isNull)
              // Print each null element (or a message indicating null)
              .forEach(name -> System.out.println("Found a null element."));
    }
}

    Vamos detalhar as novas partes:

    • import java.util.Arrays;: Precisamos importar a classe Arrays para usar seu método stream().
    • import java.util.Objects;: Importamos a classe Objects para usar o método isNull(), que é uma maneira conveniente de verificar se um objeto é null.
    • Arrays.stream(names): Esta linha converte nosso array names em um Stream de objetos String.
    • .filter(Objects::isNull): Esta é uma operação intermediária. Ela filtra o stream, mantendo apenas os elementos para os quais a condição Objects.isNull(element) é verdadeira (ou seja, os elementos que são null). Objects::isNull é uma referência de método, uma abreviação para uma expressão lambda name -> Objects.isNull(name).
    • .forEach(name -> System.out.println("Found a null element."));: Esta é uma operação terminal. Ela executa uma ação para cada elemento restante no stream (que são os elementos null após a filtragem). Neste caso, ela imprime "Found a null element." para cada null encontrado.

  3. Salve o arquivo HelloJava.java.

  4. Compile o programa no Terminal:

    javac HelloJava.java

  5. Execute o programa:

    java HelloJava

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

    Checking array for null values using Stream API:
Found a null element.
Found a null element.

    Esta saída confirma que a Stream API identificou com sucesso os dois elementos null no array. Usar streams pode tornar seu código mais legível e expressivo para certas operações, como filtragem e processamento de coleções.

Contar Elementos Nulos

Nas etapas anteriores, aprendemos como identificar elementos null em um array usando um loop for e a Stream API. Às vezes, em vez de apenas identificar os elementos null, você pode precisar saber exatamente quantos elementos null estão presentes em um array. Nesta etapa, aprenderemos como contar o número de elementos null usando a Stream API.

A Stream API fornece um método conveniente chamado count(), que, quando aplicado a um stream, retorna o número de elementos nesse stream. Podemos combinar isso com a operação filter() que usamos antes para contar apenas os elementos null.

Vamos modificar nosso programa HelloJava.java mais uma vez para contar os elementos null e imprimir a contagem total.

  1. Abra o arquivo HelloJava.java no editor WebIDE.

  2. Substitua o código existente pelo seguinte:

    import java.util.Arrays;
import java.util.Objects;

public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[5];
        names[0] = "Alice";
        names[1] = "Bob";
        names[2] = null;
        names[3] = "Charlie";
        names[4] = null;

        System.out.println("Counting null values using Stream API:");

        // Convert the array to a Stream
        long nullCount = Arrays.stream(names)
                              // Filter for null elements
                              .filter(Objects::isNull)
                              // Count the remaining elements (which are null)
                              .count();

        System.out.println("Total number of null elements: " + nullCount);
    }
}

    Aqui está o que é novo:

    • long nullCount = ... .count();: Após filtrar o stream para incluir apenas elementos null, chamamos a operação terminal count(). Esta operação retorna o número de elementos no stream filtrado como um valor long, que armazenamos na variável nullCount.
    • System.out.println("Total number of null elements: " + nullCount);: Esta linha imprime a contagem final de elementos null.

  3. Salve o arquivo HelloJava.java.

  4. Compile o programa no Terminal:

    javac HelloJava.java

  5. Execute o programa:

    java HelloJava

    Você deve ver a seguinte saída:

    Counting null values using Stream API:
Total number of null elements: 2

    Esta saída mostra que nosso programa contou corretamente os dois elementos null no array. Usar os métodos filter() e count() da Stream API juntos é uma maneira eficiente e legível de contar tipos específicos de elementos em uma coleção, incluindo valores null.

Você agora aprendeu três maneiras diferentes de lidar com valores null em um array Java: usando um loop for tradicional para verificar cada elemento, usando a Stream API para filtrar e identificar elementos null e usando a Stream API para filtrar e contar elementos null. Essas técnicas são fundamentais para escrever código Java robusto que evita NullPointerExceptions.

Resumo

Neste laboratório, aprendemos como verificar elementos nulos em um array Java usando diferentes abordagens. Começamos implementando um loop tradicional para iterar pelo array e verificar explicitamente cada elemento em busca de um valor nulo usando uma condição if. Este método fornece uma maneira clara e fundamental de identificar nulos e é útil para entender o conceito básico de tratamento de nulos em arrays.

Em seguida, exploramos técnicas mais modernas e concisas para detecção de nulos. O laboratório demonstrou como aproveitar a Java Stream API para verificar eficientemente a existência de nulos. Essa abordagem utiliza operações de stream para processar os elementos do array e determinar a presença de nulos em um estilo mais funcional. Finalmente, aprendemos como contar o número de elementos nulos dentro de um array, fornecendo uma maneira de quantificar a extensão dos valores nulos presentes. Esses métodos oferecem diferentes níveis de expressividade e eficiência para lidar com nulos em arrays Java.

Relacionados Java Cursos
Java para Iniciantes

Java para Iniciantes

java
Exercícios de Programação Java

Exercícios de Programação Java

java
Inserção em Massa de Dados na Grade de Cursos

Inserção em Massa de Dados na Grade de Cursos

java