Como Verificar se um Array é Nulo em Java - Evite NullPointerExceptions

Introdução

Neste laboratório, você aprenderá como verificar se um array em Java é nulo. Começaremos entendendo como verificar se a própria referência do array é nula para evitar NullPointerExceptions.

Em seguida, exploraremos como combinar verificações de nulidade com verificações de comprimento para um tratamento de array mais robusto. Finalmente, você testará sua compreensão trabalhando com um array vazio inicializado.

Verificar Referência do Array para Nulo

Nesta etapa, aprenderemos como verificar se uma referência de array em Java é null. Verificar se é null é uma prática fundamental na programação Java para evitar NullPointerExceptions, que são erros comuns em tempo de execução.

Um NullPointerException ocorre quando você tenta usar uma variável que não se refere a nada (é null) como se fosse um objeto. Imagine tentar abrir uma caixa que não existe – isso é semelhante ao que acontece quando você recebe um NullPointerException.

Vamos criar um programa Java simples para demonstrar como verificar uma referência de array null.

Abra o arquivo HelloJava.java no editor WebIDE, caso ainda não esteja aberto.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Declarando uma referência de array e definindo-a como null

        // Verifique se a referência do array é nula antes de tentar usá-la
        if (names == null) {
            System.out.println("The 'names' array is null.");
        } else {
            System.out.println("The 'names' array is not null.");
        }
    }
}
```
Vamos analisar as novas partes deste código:
- String[] names = null;: Esta linha declara uma variável de array chamada names que pode conter objetos String. Em seguida, atribuímos imediatamente o valor null a ela. Isso significa que a variável names atualmente não se refere a nenhum objeto de array real na memória.
- if (names == null): Esta é uma instrução if, que é usada para tomar decisões na programação. Ela verifica se a condição dentro dos parênteses (names == null) é verdadeira. O operador == é usado para comparar se a variável names é igual a null.
- System.out.println("The 'names' array is null.");: Esta linha será executada somente se a condição names == null for verdadeira.
- System.out.println("The 'names' array is not null.");: Esta linha será executada somente se a condição names == null for falsa (significando que names não é null).
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado. No Terminal, execute:
```
javac HelloJava.java
```
Se a compilação for bem-sucedida, você não verá nenhuma saída.
Execute o programa compilado:
```
java HelloJava
```
Você deve ver a seguinte saída:
```
The 'names' array is null.
```
Esta saída confirma que nossa verificação identificou corretamente a referência do array names como null.

Entender como verificar se é null é crucial para escrever código Java robusto. Na próxima etapa, exploraremos o que acontece quando tentamos acessar o comprimento de um array que é null e como combinar verificações.

Combinar Verificações de Nulidade e Comprimento

Na etapa anterior, aprendemos como verificar se uma referência de array é null. Agora, vamos explorar o que acontece quando tentamos acessar o comprimento de um array null e como combinar a verificação de null com uma verificação do comprimento do array.

Tentar acessar a propriedade .length de uma referência de array null resultará em um NullPointerException. Isso ocorre porque você está tentando acessar uma propriedade de algo que não existe.

Vamos modificar nosso programa para demonstrar isso e, em seguida, adicionar uma verificação combinada.

Abra o arquivo HelloJava.java no editor WebIDE.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Declarando uma referência de array e definindo-a como null

        // Tentando acessar o comprimento de um array nulo (causará um erro)
        // int length = names.length; // Descomentar esta linha causaria um NullPointerException

        // Combinar verificação de nulidade e verificação de comprimento
        if (names != null && names.length > 0) {
            System.out.println("The 'names' array is not null and has elements.");
        } else {
            System.out.println("The 'names' array is null or empty.");
        }
    }
}
```
Aqui está o que é novo ou foi alterado:
- Mantivemos String[] names = null; para começar com um array null.
- A linha comentada // int length = names.length; mostra o que aconteceria se tentássemos acessar o comprimento diretamente. Comentamos para que o programa não trave imediatamente.
- if (names != null && names.length > 0): Esta é a verificação combinada.
  - names != null: Esta parte verifica se a referência do array names não é null.
  - &&: Este é o operador lógico AND. Ambas as condições em ambos os lados de && devem ser verdadeiras para que toda a condição seja verdadeira.
  - names.length > 0: Esta parte verifica se o comprimento do array names é maior que 0. Esta verificação é executada somente se a primeira parte (names != null) for verdadeira, graças à natureza de curto-circuito do operador && em Java. Isso evita o NullPointerException.
- O bloco else agora imprime uma mensagem indicando que o array é null ou vazio.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado:
```
javac HelloJava.java
```
Novamente, se for bem-sucedido, não haverá saída.
Execute o programa compilado:
```
java HelloJava
```
Você deve ver a seguinte saída:
```
The 'names' array is null or empty.
```
Esta saída mostra que nossa verificação combinada identificou corretamente que o array era null ou vazio. Como o inicializamos como null, a primeira parte da condição if (names != null) foi falsa, e o bloco else foi executado.

Combinar verificações como esta é uma maneira padrão de lidar com referências de array em Java com segurança, garantindo que você não encontre NullPointerExceptions ao verificar propriedades como comprimento ou acessar elementos.

Testar com Array Vazio Inicializado

Nas etapas anteriores, aprendemos sobre como verificar referências de array null e combiná-las com uma verificação de comprimento. Vimos que nossa verificação combinada identificou corretamente um array null.

Agora, vamos testar nossa verificação combinada com um array que não é null, mas está vazio (tem um comprimento de 0). Este é outro cenário comum que você encontrará.

Abra o arquivo HelloJava.java no editor WebIDE.
Modifique a linha onde declaramos e inicializamos o array names. Altere String[] names = null; para String[] names = new String[0];. O restante do código, incluindo a instrução if com a verificação combinada, deve permanecer o mesmo.

O código atualizado deve ser assim:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[0]; // Declarando e inicializando um array vazio

        // Combinar verificação de nulidade e verificação de comprimento
        if (names != null && names.length > 0) {
            System.out.println("The 'names' array is not null and has elements.");
        } else {
            System.out.println("The 'names' array is null or empty.");
        }
    }
}
```
Aqui está a alteração:
- String[] names = new String[0];: Esta linha agora cria um novo array de objetos String com um tamanho de 0. A variável names agora se refere a um objeto de array real na memória, mas esse array não contém elementos. Ele não é null.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado:
```
javac HelloJava.java
```
Se a compilação for bem-sucedida, não haverá saída.
Execute o programa compilado:
```
java HelloJava
```
Você deve ver a seguinte saída:
```
The 'names' array is null or empty.
```
Esta saída é a mesma de quando o array era null. Vamos entender o porquê. Nossa condição if é if (names != null && names.length > 0).
- names != null: Esta parte agora é verdadeira porque names se refere a um objeto de array vazio.
- names.length > 0: Esta parte verifica se o comprimento do array é maior que 0. Como o array tem um comprimento de 0, esta condição é falsa.
- Como a segunda parte da condição && é falsa, toda a condição (names != null && names.length > 0) é avaliada como falsa, e o bloco else é executado.

Isso demonstra que nossa verificação combinada identifica corretamente arrays null e arrays vazios, que geralmente é o comportamento desejado quando você deseja processar um array somente se ele contiver elementos.

Resumo

Neste laboratório, aprendemos como verificar se uma referência de array em Java é null para evitar NullPointerExceptions. Começamos criando um programa simples para demonstrar a verificação de uma referência de array null usando uma instrução if e o operador ==.

Em seguida, exploramos a combinação da verificação de null com uma verificação de comprimento para lidar com casos em que o array não é null, mas pode estar vazio. Finalmente, testamos nossa verificação combinada com um array vazio inicializado para entender a diferença entre uma referência de array null e um array vazio.