Como Verificar se um Booleano é Nulo em Java - Evitando NullPointerException

Introdução

Neste laboratório, você aprenderá como lidar com segurança com valores null ao trabalhar com objetos Boolean em Java. Exploraremos as armadilhas potenciais da NullPointerException ao lidar com a classe wrapper Boolean em comparação com o tipo primitivo boolean.

Você aprenderá a maneira correta de verificar se um objeto Boolean é null antes de acessar seu valor, utilizar a classe Optional para um tratamento de nulos mais robusto e entender as principais diferenças no comportamento de nulos entre o boolean primitivo e a classe wrapper Boolean por meio de exemplos práticos.

Verificar Objeto Booleano para Nulo

Nesta etapa, exploraremos como lidar com valores null potenciais ao trabalhar com objetos Boolean em Java. Diferentemente dos tipos primitivos boolean, que são sempre true ou false, a classe wrapper Boolean pode conter um valor null. Esta é uma fonte comum de erros NullPointerException se não for tratada com cuidado.

Vamos criar um programa Java simples para demonstrar isso.

Abra o editor WebIDE.
No File Explorer à esquerda, certifique-se de estar no diretório ~/project.
Clique com o botão direito no espaço vazio no File Explorer, selecione "New File" e nomeie-o como BooleanCheck.java.
Abra o arquivo BooleanCheck.java no editor.

Copie e cole o seguinte código no editor:

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

        // This will cause a NullPointerException if myBoolean is null
        // if (myBoolean) {
        //     System.out.println("myBoolean is true");
        // }

        // Correct way to check for null before accessing the boolean value
        if (myBoolean != null && myBoolean) {
            System.out.println("myBoolean is true");
        } else if (myBoolean == null) {
            System.out.println("myBoolean is null");
        } else {
            System.out.println("myBoolean is false");
        }
    }
}

Neste código:

Declaramos um objeto Boolean chamado myBoolean e o inicializamos com null.
A linha comentada if (myBoolean) mostra um erro comum que leva a um NullPointerException quando myBoolean é null.
A linha if (myBoolean != null && myBoolean) demonstra a maneira correta de verificar se o objeto Boolean não é null antes de tentar avaliar seu valor booleano. O operador && é um operador de curto-circuito, o que significa que se myBoolean != null for falso, a segunda parte (myBoolean) não é avaliada, evitando o erro.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project usando o comando cd ~/project.
Compile o programa Java digitando o seguinte comando e pressionando Enter:
```
javac BooleanCheck.java
```
Se não houver erros, você não verá nenhuma saída. Um arquivo BooleanCheck.class será criado no diretório ~/project.
Execute o programa compilado usando o seguinte comando e pressionando Enter:
```
java BooleanCheck
```
Você deve ver a saída:
```
myBoolean is null
```
Esta saída confirma que nosso programa identificou corretamente que myBoolean era null e evitou o NullPointerException. Entender como lidar com null com objetos Boolean é crucial para escrever código Java robusto.

Usar Optional para Tratamento de Nulos

Nesta etapa, exploraremos uma abordagem mais moderna para lidar com valores null potenciais em Java usando a classe Optional, introduzida no Java 8. Optional é um objeto contêiner que pode ou não conter um valor não nulo. Ele fornece uma maneira clara de indicar que um valor pode estar ausente, ajudando a prevenir erros NullPointerException e tornando o código mais legível.

Vamos modificar nosso exemplo anterior para usar Optional<Boolean>.

Abra o arquivo BooleanCheck.java no editor WebIDE.

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

import java.util.Optional;

public class BooleanCheck {
    public static void main(String[] args) {
        // Creating an Optional that contains a Boolean value
        Optional<Boolean> optionalBooleanPresent = Optional.of(true);

        // Creating an Optional that is empty (represents null)
        Optional<Boolean> optionalBooleanEmpty = Optional.empty();

        // Handling the present Optional
        if (optionalBooleanPresent.isPresent()) {
            System.out.println("optionalBooleanPresent has a value: " + optionalBooleanPresent.get());
        } else {
            System.out.println("optionalBooleanPresent is empty");
        }

        // Handling the empty Optional
        if (optionalBooleanEmpty.isPresent()) {
            System.out.println("optionalBooleanEmpty has a value: " + optionalBooleanEmpty.get());
        } else {
            System.out.println("optionalBooleanEmpty is empty");
        }

        // Using orElse to provide a default value if the Optional is empty
        Boolean valueOrDefault = optionalBooleanEmpty.orElse(false);
        System.out.println("Value from optionalBooleanEmpty orElse(false): " + valueOrDefault);

        // Using ifPresent to perform an action only if a value is present
        optionalBooleanPresent.ifPresent(value -> System.out.println("Value is present: " + value));
    }
}

Neste código atualizado:

Importamos a classe java.util.Optional.
Criamos dois objetos Optional<Boolean>: um com um valor (Optional.of(true)) e outro que está vazio (Optional.empty()).
Usamos isPresent() para verificar se um Optional contém um valor.
Usamos get() para recuperar o valor de um Optional. Observação: Chamar get() em um Optional vazio lançará uma NoSuchElementException, portanto, sempre verifique com isPresent() primeiro ou use outros métodos Optional.
Demonstramos orElse(false), que retorna o valor contido se presente, caso contrário, retorna o valor padrão especificado (false neste caso).
Mostramos ifPresent(), que recebe uma expressão lambda e a executa somente se um valor estiver presente no Optional.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project usando o comando cd ~/project.
Compile o programa Java digitando o seguinte comando e pressionando Enter:
```
javac BooleanCheck.java
```
Se a compilação for bem-sucedida, um novo arquivo BooleanCheck.class será gerado.
Execute o programa compilado usando o seguinte comando e pressionando Enter:
```
java BooleanCheck
```
Você deve ver a seguinte saída:
```
optionalBooleanPresent has a value: true
optionalBooleanEmpty is empty
Value from optionalBooleanEmpty orElse(false): false
Value is present: true
```
Esta saída mostra como Optional pode ser usado para lidar com a presença ou ausência de um valor de uma forma mais explícita e segura do que apenas usar null. Usar Optional pode tornar seu código mais claro e reduzir a probabilidade de NullPointerExceptions.

Testar com Primitivos vs Wrappers

Nesta etapa, destacaremos a diferença fundamental entre o tipo primitivo boolean do Java e a classe wrapper Boolean, especificamente em relação à sua capacidade de ser null. Compreender essa distinção é fundamental para evitar NullPointerExceptions ao trabalhar com valores booleanos.

Primitivo boolean: Este é um tipo de dado básico em Java. Ele só pode conter um de dois valores: true ou false. Uma variável primitiva boolean nunca pode ser null.
Classe Wrapper Boolean: Este é um objeto que encapsula um valor primitivo boolean. Por ser um objeto, uma variável Boolean pode conter uma referência a um objeto Boolean (que contém true ou false) ou pode conter o valor null.

Vamos criar um programa simples para demonstrar essa diferença.

Abra o editor WebIDE.
No File Explorer à esquerda, certifique-se de estar no diretório ~/project.
Clique com o botão direito no espaço vazio no File Explorer, selecione "New File" e nomeie-o como PrimitiveVsWrapper.java.
Abra o arquivo PrimitiveVsWrapper.java no editor.

Copie e cole o seguinte código no editor:

public class PrimitiveVsWrapper {
    public static void main(String[] args) {
        // Declaring a primitive boolean
        boolean primitiveBoolean = true;

        // Declaring a Boolean wrapper object
        Boolean wrapperBoolean = null; // Wrapper can be null

        System.out.println("Primitive boolean value: " + primitiveBoolean);

        // Checking if the wrapper Boolean is null before printing
        if (wrapperBoolean == null) {
            System.out.println("Wrapper Boolean is null");
        } else {
            System.out.println("Wrapper Boolean value: " + wrapperBoolean);
        }

        // Attempting to assign null to a primitive boolean will cause a compile-time error
        // primitiveBoolean = null; // Uncommenting this line will cause an error
    }
}

Neste código:

Declaramos um boolean primitivo e o inicializamos com true.
Declaramos um objeto wrapper Boolean e o inicializamos com null. Isso é válido para a classe wrapper.
Imprimimos o valor do booleano primitivo.
Verificamos se o booleano wrapper é null antes de tentar imprimir seu valor, demonstrando a necessidade de verificações de null com tipos wrapper.
A linha comentada mostra que você não pode atribuir null a um boolean primitivo. Se você descomentar esta linha e tentar compilar, obterá um erro de compilação.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project usando o comando cd ~/project.
Compile o programa Java digitando o seguinte comando e pressionando Enter:
```
javac PrimitiveVsWrapper.java
```
Se não houver erros, um arquivo PrimitiveVsWrapper.class será criado.
Execute o programa compilado usando o seguinte comando e pressionando Enter:
```
java PrimitiveVsWrapper
```
Você deve ver a seguinte saída:
```
Primitive boolean value: true
Wrapper Boolean is null
```
Esta saída mostra claramente que o boolean primitivo contém um valor (true), enquanto o objeto wrapper Boolean pode conter null. Essa distinção é importante ao projetar seus programas Java e lidar com possíveis valores ausentes.

Resumo

Neste laboratório, aprendemos como lidar com valores null potenciais ao trabalhar com objetos Boolean em Java. Vimos que, ao contrário dos tipos primitivos boolean, a classe wrapper Boolean pode ser null, o que pode levar a erros NullPointerException. Demonstramos a maneira correta de verificar se um objeto Boolean não é null antes de acessar seu valor booleano, usando a verificação != null combinada com o operador lógico AND (&&). Isso garante que o valor booleano seja avaliado somente se o objeto não for nulo, evitando erros em tempo de execução.