web-dev-qa-db-fra.com

Le meilleur moyen de vérifier les valeurs NULL en Java?

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

Quelle est la meilleure manière de s'occuper de ça? J'ai considéré ces méthodes. 
Quelle 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...
}
javanullnullpointerexception
27
Arty-fishL

La méthode 4 est la meilleure.

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

utilisera court-circuit evaluation , ce qui signifie qu'elle se termine si la première condition d'un logical AND est fausse.

56
Jared Nielsen

Le dernier et le meilleur. i.e LOGICAL ET

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

Parce que dans && logique 

il n'est pas nécessaire de connaître le côté droit, le résultat doit être faux 

Vous préférez lire: l'opérateur logique Java court-circuitant

11
Suresh Atta

En Java 8, le meilleur moyen de vérifier la valeur null est le suivant:

Objects.isNull(obj) //returns true if the object is null

Objects.nonNull(obj) //returns true if object is not-null

if(Objects.nonNull(foo) && foo.something()) // Uses short-circuit as well. No Null-pointer Exceptions are thrown.

En dehors de cela ... Vous pouvez également aller avec la classe facultative de Guava

Réduit les erreurs typologiques telles que (obj=null), qui renvoie toujours true, comme indiqué dans les réponses précédentes.

7
Mohamed Anees A
  • Ne pas attraper NullPointerException. C'est une mauvaise pratique. Il est préférable de s’assurer que la valeur n’est pas nulle.
  • La méthode n ° 4 fonctionnera pour vous. Elle n'évaluera pas la deuxième condition, car Java est court-circuité (les conditions suivantes ne seront pas évaluées si elles ne modifient pas le résultat final de l'expression booléenne). Dans ce cas, si la première expression d'un ET logique est évaluée à false, il n'est pas nécessaire d'évaluer les expressions suivantes.
5
Vivin Paliath

La méthode 4 est de loin la meilleure, car elle indique clairement ce qui va se passer et utilise le minimum de code.

La méthode 3 est juste fausse à tous les niveaux. Vous savez que l'élément peut être nul, ce n'est donc pas une situation exceptionnelle, c'est quelque chose que vous devriez vérifier.

La méthode 2 ne fait que rendre les choses plus compliquées que nécessaire.

La méthode 1 est simplement la méthode 4 avec une ligne de code supplémentaire.

4
wobblycogs

Je dirais que la méthode 4 est l'idiome le plus général du code que j'ai examiné. Mais ça sent toujours un peu mauvais pour moi. Il suppose que foo == null est identique à foo.bar () == false. 

Cela ne me semble pas toujours juste.

2
DaveH

La méthode 4 est ma méthode préférée. Le court-circuit de l'opérateur && rend le code le plus lisible. La méthode 3, Catching NullPointerException, est souvent mal vue lorsqu'une simple vérification de null suffit.

2
aglassman

Dans Java 7 , vous pouvez utiliser Objects.requireNonNull(). Ajoutez une importation de Objects class à partir de Java.util.

public class FooClass {
    //...
    public void acceptFoo(Foo obj) {
        //If obj is null, NPE is thrown
        Objects.requireNonNull(obj).bar(); //or better requireNonNull(obj, "obj is null");
    }
    //...
}
2
KrishPrabakar

Comme d'autres l'ont déjà dit, # 4 est la meilleure méthode lorsque vous n'utilisez pas de méthode de bibliothèque. Cependant, vous devez toujours mettre null à gauche de la comparaison pour vous assurer de ne pas affecter accidentellement null à foo en cas de frappe. Dans ce cas, le compilateur va attraper l'erreur.

// You meant to do this
if(foo != null){

// But you made a typo like this which will always evaluate to true
if(foo = null)

// Do the comparison in this way
if(null != foo)

// So if you make the mistake in this way the compiler will catch it
if(null = foo){

// obviously the typo is less obvious when doing an equality comparison but it's a good habit either way
if(foo == null){
if(foo =  null){
1
Jay Eskandarian

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

1
Durgpal Singh

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

Plus d'infos ici . Modifiez votre méthode pour renvoyer un Optional<Boolean> au lieu d'une Boolean.

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

1
Sam Barnum

Si du tout vous allez vérifier avec double égal "==", cochez null avec l'objet ref comme 

if(null == obj)

au lieu de 

if(obj == null)

parce que si vous tapez un type égal à égal égal à if (obj = null), il retournera la valeur true (l'affectation de l'objet renvoie le succès (ce qui correspond à la valeur "true").

1
user3107979

si vous n'avez pas accès à la bibliothèque commune d'Apache, ce qui suit fonctionnera probablement correctement

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

Code simple à une ligne pour vérifier la valeur null:

namVar == null ? codTdoForNul() : codTdoForFul();
0
Sujay U N

Nous pouvons utiliser la méthode statique Object.requireNonNull de la classe Object. La mise en œuvre est ci-dessous

public void someMethod(SomeClass obj) {
    Objects.requireNonNull(obj, "Validation error, obj cannot be null");
}
0
Akash Nema

Votre dernière proposition est la meilleure. 

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

Parce que:

  1. C'est plus facile à lire.
  2. C'est sûr: foo.bar () ne sera jamais exécuté si foo == null.
  3. Cela évite les mauvaises pratiques comme attraper NullPointerExceptions (la plupart du temps à cause d'un bug dans votre code)
  4. Il devrait fonctionner aussi vite ou même plus rapidement que les autres méthodes (même si je pense qu'il devrait être presque impossible de le remarquer).
0
C.Champagne