Meilleur moyen de vérifier les valeurs nulles en Java ?

Question

Avant d'appeler une fonction d'un objet, je dois vérifier si l'objet est nul, afin d'éviter de lancer un message de type NullPointerException .

Quelle est la meilleure façon de procéder ? J'ai envisagé ces méthodes.
Laquelle est la meilleure pratique de programmation pour Java ?

// Method 1
if (foo != null) {
    if (foo.bar()) {
        etc...
    }
}

// Method 2
if (foo != null ? foo.bar() : false) {
    etc...
}

// Method 3
try {
    if (foo.bar()) {
        etc...
    }
} catch (NullPointerException e) {
}

// Method 4 -- Would this work, or would it still call foo.bar()?
if (foo != null && foo.bar()) {
    etc...
}

Answer 1

Si vous contrôlez l'API appelée, envisagez d'utiliser la fonction La classe facultative de Guava

Plus d'informations ici . Changez votre méthode pour retourner un Optional<Boolean> au lieu d'un Boolean .

Cela informe le code appelant qu'il doit tenir compte de la possibilité de null, en appelant l'une des méthodes pratiques de la section Optional

Answer 2

Vous pouvez également utiliser StringUtils.isNoneEmpty("") pour la vérification est nulle ou vide.

Answer 3

Mise à jour

J'ai créé une bibliothèque java (dépendance Maven) pour que les développeurs java puissent supprimer cette NullPointerException Hell de leur code. Consultez mon dépôt.

Référentiel NullUtil

Méthode générique pour traiter les valeurs nulles en Java

<script src="https://gist.github.com/rcvaram/f1a1b89193baa1de39121386d5f865bc.js"></script>

1. Si cet objet n'est pas nul, nous allons faire les choses suivantes.

   a. Nous pouvons muter l'objet (I)

   b. Nous pouvons retourner quelque chose (O) comme sortie au lieu de muter l'objet (I).

   c. nous pouvons faire les deux

Dans ce cas, nous devons passer une fonction qui doit prendre le paramètre d'entrée (I) qui est notre objet Si nous le prenons comme ça, alors nous pouvons muter cet objet si nous le voulons. et aussi cette fonction peut être quelque chose (O).

2. Si un objet est nul, nous allons faire les choses suivantes

   a. Nous pouvons lancer une exception d'une manière personnalisée

   b. Nous pouvons rendre quelque chose.

Dans ce cas, l'objet est nul, nous devons donc fournir la valeur ou nous devrons peut-être lever une exception.

Je prends deux exemples.

1. Si je veux exécuter une coupe dans une chaîne de caractères, cette chaîne ne doit pas être nulle. Dans ce cas, nous devons vérifier en plus la valeur nulle, sinon nous obtiendrons une NullPointerException.

   public String trimValue(String s){ return s == null ? null : s.trim(); }

2. Une autre fonction pour laquelle je veux définir une nouvelle valeur pour un objet si cet objet n'est pas nul, sinon je veux lancer une exception d'exécution.

   public void setTeacherAge(Teacher teacher, int age){ if (teacher != null){ teacher.setAge(age); } else{ throw new RuntimeException("teacher is null") } }

Avec mon explication, j'ai créé une méthode générique qui prend la valeur (la valeur peut être nulle), une fonction qui s'exécutera si l'objet n'est pas nul et une autre fonction fournisseur qui s'exécutera si l'objet est nul.

Fonction générique

  public <I, O> O setNullCheckExecutor(I value, Function<I, O> nonNullExecutor, Supplier<O> nullExecutor) {
        return value != null ? nonNullExecutor.apply(value) : nullExecutor.get();
    }

Donc après avoir eu cette fonction générique, nous pouvons faire comme suit pour les méthodes de l'exemple 1.

//To Trim a value
        String trimmedValue = setNullCheckExecutor(value, String::trim, () -> null);

Ici, la fonction nonNullExecutorFunction coupe la valeur (la référence de la méthode est utilisée). La fonction nullExecutorFunction renvoie un résultat nul puisqu'il s'agit d'une fonction d'identité.

2.

// mutate the object if not null otherwise throw a custom message runtime exception instead of NullPointerException
 setNullCheckExecutor(teacher, teacher -> {
            teacher.setAge(19);
            return null;
        }, () -> {
            throw new RuntimeException("Teacher is null");
        });

Answer 4

Si vous n'avez pas accès à la bibliothèque commons apache, la méthode suivante fonctionnera probablement bien.

if(null != foo && foo.bar()) {
//do something
}

Answer 5

Votre dernière proposition est la meilleure.

if (foo != null && foo.bar()) {
    etc...
}

Parce que :

1. Il est plus facile à lire.
2. C'est sûr : foo.bar() ne sera jamais exécuté si foo == null.
3. Il évite les mauvaises pratiques telles que la capture d'exceptions NullPointerExceptions (la plupart du temps dues à un bug dans votre code).
4. Il devrait s'exécuter aussi vite, voire plus vite, que les autres méthodes (même si je pense qu'il devrait être presque impossible de le remarquer).