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

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?

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

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.

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.

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

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)) { 

}