Como Verificar se um Objeto Booleano é Nulo em Java - Evite NullPointerException

Introdução

Neste laboratório, você aprenderá como verificar com segurança se um objeto wrapper Boolean é null em Java. Diferente do tipo primitivo boolean, a classe Boolean pode conter um valor null, o que pode levar a uma NullPointerException se não for tratado corretamente.

Exploraremos diferentes técnicas para lidar com objetos Boolean null, incluindo verificações diretas de nulo, combinação de verificações de nulo e true/false, e a utilização da classe Optional para um tratamento de nulo mais robusto. Ao final deste laboratório, você estará equipado para evitar armadilhas comuns ao trabalhar com objetos wrapper Boolean em Java.

Testar Wrapper Booleano para Nulo

Nesta etapa, exploraremos como lidar com objetos wrapper Boolean em Java, focando especificamente em verificar se um objeto Boolean é null. Diferente do tipo primitivo boolean, que só pode ser true ou false, a classe wrapper Boolean também pode conter um valor null. Esta é uma fonte comum de NullPointerException se não for tratada com cuidado.

Vamos criar um programa Java simples para demonstrar isso.

Abra o diretório ~/project no Explorador de Arquivos no lado esquerdo do WebIDE.
Clique com o botão direito no espaço vazio dentro do diretório ~/project e selecione "Novo Arquivo".
Nomeie o novo arquivo BooleanCheck.java e pressione Enter.
Abra o arquivo BooleanCheck.java no Editor de Código.

Copie e cole o seguinte código Java no editor:

public class BooleanCheck {

    public static void main(String[] args) {
        Boolean myBoolean = null;

        // Attempting to directly use a null Boolean in a conditional
        // will cause a NullPointerException
        // if (myBoolean) {
        //     System.out.println("This will not be printed if myBoolean is null.");
        // }

        // Correct way to check if a Boolean wrapper is null
        if (myBoolean == null) {
            System.out.println("myBoolean is null.");
        } else {
            System.out.println("myBoolean is not null.");
        }

        // Another way to check the boolean value safely
        if (Boolean.TRUE.equals(myBoolean)) {
             System.out.println("myBoolean is true.");
        } else if (Boolean.FALSE.equals(myBoolean)) {
             System.out.println("myBoolean is false.");
        } else {
             System.out.println("myBoolean is null (checked using equals).");
        }
    }
}

Salve o arquivo pressionando Ctrl + S (ou Cmd + S no Mac).
Agora, vamos compilar o programa Java. Abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project. Caso contrário, digite cd ~/project e pressione Enter.
Compile o código usando o comando javac:
```
javac BooleanCheck.java
```
Se não houver erros, o comando será concluído sem saída. Isso significa que um arquivo BooleanCheck.class foi criado no diretório ~/project.
Execute o programa Java compilado usando o comando java:
```
java BooleanCheck
```

Você deve ver a seguinte saída no Terminal:

myBoolean is null.
myBoolean is null (checked using equals).

Esta saída confirma que nosso código identificou corretamente o objeto Boolean como null usando a verificação == null e o padrão Boolean.TRUE.equals() / Boolean.FALSE.equals(). O código comentado mostra o que aconteceria se você tentasse usar um Boolean null diretamente em uma condição if, o que resultaria em uma NullPointerException.

Compreender como lidar com segurança com objetos Boolean null é crucial para evitar erros comuns na programação Java.

Combinar Verificações de Nulo e Verdadeiro/Falso

Na etapa anterior, vimos como verificar se um objeto Boolean é null. Frequentemente, você precisa verificar se um Boolean é true, false ou null. Combinar essas verificações de forma eficiente e segura é importante.

Vamos modificar nosso programa BooleanCheck.java para demonstrar como lidar com todas as três possibilidades.

Abra o arquivo BooleanCheck.java no Editor de Código, caso ainda não esteja aberto. Ele deve estar localizado no diretório ~/project.

Substitua o código existente em BooleanCheck.java pelo seguinte código. Esta versão inclui exemplos para valores Boolean null, true e false.

public class BooleanCheck {

    public static void main(String[] args) {
        Boolean booleanValue1 = null;
        Boolean booleanValue2 = true;
        Boolean booleanValue3 = false;

        System.out.println("Checking booleanValue1 (null):");
        checkBoolean(booleanValue1);

        System.out.println("\nChecking booleanValue2 (true):");
        checkBoolean(booleanValue2);

        System.out.println("\nChecking booleanValue3 (false):");
        checkBoolean(booleanValue3);
    }

    // A helper method to demonstrate the checks
    public static void checkBoolean(Boolean value) {
        if (value == null) {
            System.out.println("Value is null.");
        } else if (value) { // This is safe because we already checked for null
            System.out.println("Value is true.");
        } else { // If not null and not true, it must be false
            System.out.println("Value is false.");
        }

        // Another common pattern using equals for safety
        System.out.print("Using equals: ");
        if (Boolean.TRUE.equals(value)) {
             System.out.println("Value is true.");
        } else if (Boolean.FALSE.equals(value)) {
             System.out.println("Value is false.");
        } else {
             System.out.println("Value is null.");
        }
    }
}

Neste código atualizado:

Definimos um método auxiliar checkBoolean que recebe um objeto Boolean como entrada.
Dentro de checkBoolean, primeiro verificamos se o value é null usando value == null.
Se não for null, verificamos com segurança se o valor booleano é true usando value. Isso funciona porque Java fará o auto-unbox do wrapper Boolean para um boolean primitivo somente se o wrapper não for null.
Se não for null e não for true, deve ser false, o que é tratado no bloco else.
Também incluímos o padrão Boolean.TRUE.equals(value) e Boolean.FALSE.equals(value) novamente, que é outra maneira segura de verificar o valor, especialmente útil quando você deseja evitar potenciais NullPointerException se o objeto no qual equals é chamado for null.

Salve o arquivo (Ctrl + S ou Cmd + S).
Compile o programa modificado no Terminal:
```
javac BooleanCheck.java
```
Execute o programa compilado:
```
java BooleanCheck
```

Você deve ver a seguinte saída, demonstrando como o código lida com cada caso:

Checking booleanValue1 (null):
Value is null.
Using equals: Value is null.

Checking booleanValue2 (true):
Value is true.
Using equals: Value is true.

Checking booleanValue3 (false):
Value is false.
Using equals: Value is false.

Esta etapa mostra maneiras robustas de verificar o estado de um objeto wrapper Boolean, levando em consideração valores null, true e false, o que é uma habilidade fundamental para escrever código Java seguro e confiável.

Lidar com a Classe Optional

Em Java moderno (Java 8 e posterior), a classe Optional é frequentemente usada para representar um valor que pode ou não estar presente. Isso pode ajudar a reduzir o número de NullPointerExceptions em seu código, tornando explícito quando um valor pode estar ausente. Embora Optional<Boolean> nem sempre seja o caso de uso mais comum, é uma boa maneira de entender como Optional pode ser aplicado a tipos wrapper como Boolean.

Nesta etapa, modificaremos nosso programa para usar Optional<Boolean> para lidar com a possibilidade de um valor booleano ausente.

Abra o arquivo BooleanCheck.java no Editor de Código. Ele deve estar no diretório ~/project.

Substitua o código existente pelo seguinte código que usa Optional<Boolean>:

import java.util.Optional;

public class BooleanCheck {

    public static void main(String[] args) {
        Optional<Boolean> optionalBoolean1 = Optional.empty(); // Represents no value
        Optional<Boolean> optionalBoolean2 = Optional.of(true); // Represents the value true
        Optional<Boolean> optionalBoolean3 = Optional.of(false); // Represents the value false

        System.out.println("Checking optionalBoolean1 (empty):");
        checkOptionalBoolean(optionalBoolean1);

        System.out.println("\nChecking optionalBoolean2 (true):");
        checkOptionalBoolean(optionalBoolean2);

        System.out.println("\nChecking optionalBoolean3 (false):");
        checkOptionalBoolean(optionalBoolean3);
    }

    // A helper method to demonstrate checking Optional<Boolean>
    public static void checkOptionalBoolean(Optional<Boolean> optionalValue) {
        if (optionalValue.isPresent()) {
            // Get the boolean value if present
            Boolean value = optionalValue.get();
            if (value) {
                System.out.println("Value is present and true.");
            } else {
                System.out.println("Value is present and false.");
            }
        } else {
            System.out.println("Value is not present (empty Optional).");
        }

        // Another way using orElse
        System.out.print("Using orElse(false): ");
        boolean result = optionalValue.orElse(false);
        System.out.println("Result: " + result);

        // Using ifPresent
        System.out.print("Using ifPresent: ");
        optionalValue.ifPresent(val -> System.out.println("Value is present: " + val));
        if (!optionalValue.isPresent()) {
             System.out.println("Value is not present.");
        }
    }
}

Nesta versão:

Importamos a classe java.util.Optional.
Criamos objetos Optional<Boolean> usando Optional.empty() para um valor ausente e Optional.of() para um valor presente.
O método checkOptionalBoolean agora recebe um Optional<Boolean>.
Usamos optionalValue.isPresent() para verificar se um valor está presente.
Se um valor estiver presente, o recuperamos usando optionalValue.get(). Observação: Chame get() somente após verificar isPresent(), caso contrário, você obterá um NoSuchElementException.
Também demonstramos orElse(false), que fornece um valor padrão (false neste caso) se o Optional estiver vazio.
ifPresent() permite que você execute uma ação somente se um valor estiver presente.

Salve o arquivo (Ctrl + S ou Cmd + S).
Compile o programa modificado no Terminal:
```
javac BooleanCheck.java
```
Execute o programa compilado:
```
java BooleanCheck
```

Você deve ver a seguinte saída:

Checking optionalBoolean1 (empty):
Value is not present (empty Optional).
Using orElse(false): Result: false
Using ifPresent: Value is not present.

Checking optionalBoolean2 (true):
Value is present and true.
Using orElse(false): Result: true
Using ifPresent: Value is present: true

Checking optionalBoolean3 (false):
Value is present and false.
Using orElse(false): Result: false
Using ifPresent: Value is present: false

Esta saída mostra como Optional<Boolean> pode ser usado para lidar explicitamente com a presença ou ausência de um valor booleano, fornecendo uma maneira mais robusta de lidar com dados potencialmente ausentes em comparação com o uso de um Boolean anulável.

Resumo

Neste laboratório, aprendemos como verificar se um objeto wrapper Boolean é null em Java. Exploramos a diferença entre o tipo primitivo boolean e a classe wrapper Boolean, destacando o potencial para NullPointerException ao lidar com objetos Boolean null. Demonstramos a maneira correta de verificar se é null usando o operador de igualdade (== null) e também mostramos como verificar com segurança o valor booleano usando o método equals() de Boolean.TRUE e Boolean.FALSE. Essas técnicas são cruciais para prevenir erros em tempo de execução ao trabalhar com objetos Boolean anuláveis.