java.util.Objects.isNull vs object == null


87

Comme vous le savez, java.util.Objectsest

Cette classe se compose de méthodes utilitaires statiques permettant d'opérer sur des objets.

L'une de ces méthodes est Objects.isNull().

Je crois comprendre que Objects.isNull()cela éliminerait le risque d'attribuer accidentellement une valeur nulle à object en omettant la seconde =.

Cependant, la note API indique:

Cette méthode existe pour être utilisée comme prédicat, filtre (Objects :: isNull)

Y aurait-il une raison / circonstance pour laquelle je devrais utiliser object == nullplus Objects.isNull()dans une déclaration if ?

Doit- Objects.isNull()on se limiter exclusivement aux prédicats?


3
Si tout ce que vous vous inquiétez est une affectation accidentelle, vous pouvez simplement utiliser de manière if(null == variable)cohérente…
Holger

1
@Holder, de quelle affectation accidentelle faut-il s'inquiéter? C'est Java. Vous obtiendrez une erreur de type.
Louis Wasserman

1
@LouisWasserman Pas si variablec'est un Boolean.
Alexis C.

2
@AlexisC, ce serait un problème dans un très petit nombre de cas: votre variable doit être d'un type très spécifique, et vous devez faire une faute de frappe très spécifique, et vous ne pouvez pas utiliser d'analyse IDE ou de compilateur cela indiquerait cela pour vous (comme le feraient presque tous les IDE). Je suis assez à l'aise de ne pas m'inquiéter de cette affaire.
Louis Wasserman

1
Au travail, j'ai vu de nombreuses instances d' objet nul == . Quand je me suis renseigné, on m'a dit que c'était pour éviter les assignations accidentelles nulles. Sur la base des commentaires et des réponses fournis ici, je serais porté à croire que c'est une question de goût.
Lucas T

Réponses:


79

devrait utiliser object == null sur Objects.isNull () dans une instruction if?

Si vous regardez le code source de la IsNullméthode,

 /* Returns true if the provided reference is null otherwise returns false.*/

 public static boolean isNull(Object obj) {
     return obj == null;
 }

C'est le même. Il n'y a pas de différence. Vous pouvez donc l'utiliser en toute sécurité.


14
Oui, il peut être utilisé, mais il peut interférer avec l'analyse de flux local effectuée par un outil. Par exemple, avec un simple "==", toute analyse de flux peut voir que le déréférencement n'est pas bon dans la branche then, mais sûr dans une branche else. Vous obtiendrez des erreurs / avertissements appropriés ou rien. Avec l'indirection d'appeler isNull (), cette connaissance peut être perdue pour l'outil.
Stephan Herrmann

3
Il y a une légère différence de performance. Java vérifier la référence null d'objet par rapport à l'appel d'une méthode statique aura une différence. Et cela se lit un peu moins clairement que d'utiliser simplement == auquel nous sommes tous habitués.
Kevin M du

3
Est une utilisation plus sémantique == nulldans if, mais isNull est idéal à utiliser sur les expressions lambda.
Leonardo Ramos Duarte

1
c'est sûrement légitime, mais ne présente aucun avantage sur les opérateurs. Donc, si vous travaillez en équipe, veuillez utiliser les choses en fonction de leur objectif.
Alex Panchenko

74

Objects.isNull est destiné à être utilisé dans le filtrage lambda Java 8.

C'est beaucoup plus facile et plus clair à écrire:

.stream().filter(Objects::isNull) 

que d'écrire:

.stream().filter(x -> x == null).  

Dans une ifdéclaration, cependant, l'un ou l'autre fonctionnera. L'utilisation de == nullest probablement plus facile à lire mais en fin de compte, cela se résumera à une préférence de style.


12

Regardez la source:

public static boolean isNull(Object obj) {
    return obj == null;
}

Pour vérifier les nullvaleurs, vous pouvez utiliser:

  • Objects.isNull(myObject)
  • null == myObject // avoids assigning by typo
  • myObject == null // risk of typo

Le fait qu'il Objects.isNullsoit destiné à Predicates ne vous empêche pas de l'utiliser comme ci-dessus.


1
Qu'entendez-vous par risque de faute de frappe?
Ashish Lohia

2
@AshishLohia en utilisant à la =place de ==(ne compilerait pas à moins que ce ne soit un Booleanwrapper nullable , yo be fair)
Mena

5
Le risque de faute de frappe est le problème en C ++ et non en Java si (myObject = null) entraîne une erreur de compilation. Vous devez toujours utiliser myObject == null sur null == myObject.
Tomas Marik

1
@TomasMarik comme mentionné dans mon commentaire, le risque de faute de frappe est limité aux Booleanwrappers Nullable en Java. Ceci est en effet assez rare (et donnera des avertissements au compilateur lorsqu'une affectation à nullest vérifiée comme s'il s'agissait d'une condition), mais pas impossible.
Mena

7

Y aurait-il une raison / circonstance pour laquelle je devrais utiliser object == null sur Objects.isNull () dans une instruction if ?

Oui, une des raisons est de garder le code simple. Dans si la déclaration object == null est claire et bien connue. Cela ne peut conduire à aucune mauvaise conduite si par exemple il y a une faute de frappe.

Je crois comprendre que Objects.isNull () supprimerait le risque d'attribuer accidentellement une valeur nulle à object en omettant le second =.

S'il y a un if (object = null) {}avec omis, = il ne se compilera pas ou il générera un avertissement en cas d' Booleanobjet! En fait, il n'y a aucune raison d'utiliser Objects.isNull(object)l' instruction over object == nullwithin if . Voici les deux variantes côte à côte:

if (object == null) {
}

if (Objects.isNull(object)) {
}

Objects.isNull () doit-il être limité aux prédicats exclusivement?

On pourrait dire oui, cela se limite exclusivement aux prédicats, bien qu'il n'y ait pas d'obstacle technique à utiliser Objects.isNull()partout.

Depuis le public static boolean isNull(Object obj)javadoc de la méthode:

@apiNote Cette méthode existe pour être utilisée comme java.util.function.Predicate, filter (Objects :: isNull)

Donc, si vous utilisez la méthode comme pas un prédicat, vous utilisez en fait une expression plus complexe et plus encombrante que la simple object == null.

Voici un extrait de code pour comparer les avantages de Objects.isNull(object)

List<String> list = Arrays.asList("a", "b", null, "c", null);

// As ready-made predicate
long countNullsWithPredicate = list.stream().filter(Objects::isNull).count();

// Lambda
long countNullsWithLambda = list.stream().filter(object -> object == null).count();

// Reimplement the Objects::isNull predicate
long countNullsWithAnonymous = list.stream().filter(new Predicate<Object>() {
    @Override
    public boolean test(Object obj) {
        return obj == null;
    }
}).count();

1

Sémantiquement, il n'y a pas de différence mais pour la lisibilité, je préfère ce qui suit à whatever == null:

import static java.util.Objects.isNull;

// Other stuff...

if(isNull(whatever)) { 

}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.