Como lidar com NullPointerException em Java

Se você passou algum tempo desenvolvendo programas em Java, em algum momento, definitivamente viu a seguinte exceção:

java.lang.NullPointerException

Alguns problemas importantes de produção surgem devido a NullPointerException. Neste artigo, abordaremos algumas maneiras de lidar com NullPointerException em Java.

Verificação nula simples

Considere o seguinte pedaço de código:

public static void main(String args[]) {    String input1 = null;    simpleNullCheck(input1);}private static void simpleNullCheck(String str1) {    System.out.println(str1.length());}

Se você executar esse código como está, receberá a seguinte exceção:

Exception in thread "main" java.lang.NullPointerException

O motivo pelo qual você está recebendo esse erro é porque estamos tentando executar o length() operação em str1 qual é null.

Uma solução fácil para isso é adicionar uma verificação nula em str1 como mostrado abaixo:

private static void simpleNullCheck(String str1) {    if (str1 != null) {        System.out.println(str1.length());    }}

Isso garantirá que, quando str1 é null, você não executa o length() função nele.

Mas você pode ter a seguinte pergunta.

E se str1 for uma variável importante?

Nesse caso, você pode tentar algo como isto:

 private static void simpleNullCheck(String str1) {    if (str1 != null) {        System.out.println(str1.length());    } else {        // Perform an alternate action when str1 is null        // Print a message saying that this particular field is null and hence the program has to stop and cannot continue further.    }}

A idéia é que, quando você espera que um valor seja null, é melhor colocar um null verifique essa variável. E se o valor acabar sendo null, execute uma ação alternativa.

Isso é aplicável não apenas a cadeias de caracteres, mas a qualquer outro objeto em Java.

Lombok Null Check

Agora pegue o seguinte exemplo:

public static void main(String args[]) {    String input2 = "test";    List inputList = null;    lombokNullCheck(input2, inputList, input2);}public static void lombokNullCheck(String str1, List strList, String str2) {    System.out.println(str1.length() + strList.size() + str2.length());}

Aqui temos uma função que aceita três argumentos: str1, strListe str2.

Se algum desses valores for null, não queremos executar a lógica nesta função.

Como você consegue isso?

É aqui que o Lombok é útil. Para adicionar a biblioteca Lombok ao seu código, inclua a seguinte dependência do Maven:

             org.projectlombok            lombok
            1.18.12
            provided
 

Para saber mais sobre o Maven, confira Este artigo.

Aqui está como seria o código com o Lombok null Verifica:

public static void main(String args[]) {    String input2 = "test";    List inputList = null;    try {        lombokNullCheck(input2, inputList, input2);    } catch (NullPointerException e) {        System.out.println(e);    }}public static void lombokNullCheck(@NonNull String str1, @NonNull List strList, @NonNull String str2) {    System.out.println(str1.length() + strList.size() + str2.length());}

Antes de cada argumento da função, adicionamos @NonNull anotação.

Além disso, quando chamamos essa função, colocamos um try-catch bloquear em torno da chamada de função para pegar NullPointerException.

Se algum dos argumentos apresentados na função for null, a função lançaria um NullPointerException. Isso seria capturado pelo try-catch quadra.

Isso garante que, se algum dos argumentos da função for null, a lógica da função não é executada e sabemos que o código não se comportará de maneira incomum.

Isso pode ser feito com um monte de null verifique as instruções também. Mas o uso do Lombok nos ajuda a evitar a gravação de vários null verifique as instruções e faça com que o código pareça muito mais limpo.

Listas e Nulos

Diga que você tem uma lista e deseja imprimir todos os elementos na lista:

List stringList = new ArrayList<>();stringList.add("ele1");stringList.add("ele2");if (stringList != null) {    for (String element : stringList)        System.out.println(element);}

Antes de percorrer a lista, precisamos colocar um null verifique na lista.

Se o null verificação não estiver presente e, em seguida, tentar fazer um loop sobre um null lista lançará um NullPointerException.

Mapas e Nulos

Vamos pegar o cenário em que você precisa acessar o valor para uma chave específica em um mapa:

Map testMap = new HashMap<>();testMap.put("first_key", "first_val");if (testMap != null && testMap.containsKey("first_key")) {    System.out.println(testMap.get("first_key"));}

Primeiro, precisamos fazer uma verificação nula no próprio objeto do mapa. Se isso não for feito, e o mapa estiver null, então uma NullPointerException é jogado. Isso é feito usando testMap!=null

Feito isso, verifique se uma chave específica está presente antes de acessá-la. Você pode verificar a presença da chave usando testMap.containsKey("first_key"). Se isso não for feito e a chave específica estiver ausente, você obterá o valor como null.

É necessário sempre adicionar uma verificação nula?

Se você tem certeza de que uma variável específica nunca pode ser null, evite adicionar o null Verifica. Isso pode ser aplicado em funções privadas, nas quais você pode controlar os dados que entram na função.

Mas se você não tiver certeza da anulabilidade de um objeto, é melhor adicionar um null Verifica.

Código

Todo o código discutido neste artigo pode ser encontrado neste repositório do Github.

Parabéns 😊

Agora você sabe como lidar NullPointerException em Java!

Sobre o autor

Adoro tecnologia e sigo avanços no campo. Também gosto de ajudar outras pessoas com meu conhecimento de tecnologia.

Sinta-se livre para ler mais dos meus artigos sobre meu blogconecte-se comigo no LinkedInou siga-me no Twitter.