Comment gérer NullPointerException en Java

Si vous avez passé du temps à développer des programmes en Java, à un moment donné, vous avez certainement vu l'exception suivante:

java.lang.NullPointerException

Certains problèmes de production majeurs surviennent en raison de NullPointerException. Dans cet article, nous allons passer en revue quelques façons de gérer NullPointerExceptionen Java.

Vérification nulle simple

Considérez le morceau de code suivant:

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

Si vous exécutez ce code tel quel, vous obtiendrez l'exception suivante:

Exception in thread "main" java.lang.NullPointerException

La raison pour laquelle vous obtenez cette erreur est que nous essayons d'effectuer le length()opération sur str1laquelle est null.

Une solution simple pour cela consiste à ajouter une vérification nulle sur str1comme indiqué ci-dessous:

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

Cela garantira que, lorsque str1estnull, vous n'exécutez pas le length()fonction dessus.

Mais vous vous posez peut-être la question suivante.

Et si str1 est une variable importante?

Dans ce cas, vous pouvez essayer quelque chose comme ceci:

 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. } }

L'idée est que, lorsque vous vous attendez à ce qu'une valeur soit null, il vaut mieux nullvérifier cette variable. Et si la valeur s'avère être null, prenez une autre mesure.

Cela s'applique non seulement aux chaînes, mais à tout autre objet en Java.

Vérification nulle de Lombok

Prenons maintenant l'exemple suivant:

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()); }

Ici , nous avons une fonction qui accepte trois arguments: str1, strListet str2.

Si l'une de ces valeurs s'avère être null, nous ne voulons pas du tout exécuter la logique dans cette fonction.

Comment y parvenir?

C'est là que Lombok est utile. Afin d'ajouter la bibliothèque Lombok dans votre code, incluez la dépendance Maven suivante:

  org.projectlombok lombok 1.18.12 provided 

Pour en savoir plus sur Maven, consultez cet article.

Voici à quoi ressemblerait le code avec la nullvérification de Lombok :

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()); }

Avant chaque argument de la fonction, nous ajoutons @NonNullannotation.

Aussi, lorsque nous appelons cette fonction, nous plaçons un try-catchbloc autour de l'appel de fonction à attraper NullPointerException.

Si l'un des arguments donnés dans la fonction s'avère être null, la fonction lèvera un NullPointerException. Ce serait alors attrapé par le try-catchbloc.

Cela garantit que, si l'un des arguments de la fonction s'avère être null, alors la logique de la fonction n'est pas exécutée et nous savons que le code ne se comportera pas de manière inhabituelle.

Cela peut également être fait avec un tas d' nullinstructions de contrôle. Mais l'utilisation de Lombok nous permet d'éviter d'écrire plusieurs nullinstructions de vérification et rend le code beaucoup plus propre.

Listes et valeurs nulles

Dites que vous avez une liste et que vous souhaitez imprimer tous les éléments de la liste:

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

Avant de boucler sur la liste, nous devons nullcocher la liste.

Si la nullvérification n'est pas présente, alors essayer de boucler sur une nullliste lancera un NullPointerException.

Cartes et Nulls

Prenons le scénario dans lequel vous devez accéder à la valeur d'une clé particulière dans une carte:

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

Nous devons d'abord effectuer une vérification nulle sur l'objet de la carte lui-même. Si cela n'est pas fait et que la carte l'est null, alors un NullPointerExceptionest lancé. Ceci est fait en utilisanttestMap!=null

Une fois cela fait, vérifiez si une clé particulière est présente avant d'y accéder. Vous pouvez vérifier la présence de la clé à l'aide de testMap.containsKey("first_key"). Si cela n'est pas fait et que la clé particulière est absente, vous obtiendrez la valeur comme null.

Est-il nécessaire de toujours ajouter un contrôle nul?

Si vous savez avec certitude qu'une variable particulière ne peut jamais être null, vous pouvez éviter d'ajouter la nullvérification. Cela peut être applicable dans les fonctions privées où vous pouvez contrôler les données entrant en fonction.

Mais si vous n'êtes pas vraiment certain de la nullité d'un objet, il est préférable d'ajouter une nullvérification.

Code

Tout le code abordé dans cet article se trouve dans ce dépôt Github.

Félicitations ?

Vous savez maintenant comment gérer NullPointerExceptionen Java!

A propos de l'auteur

J'adore la technologie et je suis les progrès dans le domaine. J'aime aussi aider les autres avec mes connaissances en technologie.

N'hésitez pas à lire plus de mes articles sur mon blog, à me contacter sur LinkedIn ou à me suivre sur Twitter.