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

Como sabes, java.util.Objectses

Esta clase consta de métodos de utilidad estáticos para operar con objetos.

Uno de esos métodos es Objects.isNull().

Tengo entendido que Objects.isNull()eliminaría la posibilidad de asignar accidentalmente un valor nulo al objeto omitiendo el segundo =.

Sin embargo, la nota de API dice:

Este método existe para ser utilizado como predicado, filtro (Objects :: isNull)

¿Habría alguna razón / circunstancia por la que debería usar object == nullover Objects.isNull()en una declaración if ?

¿Debería Objects.isNull()limitarse exclusivamente a los predicados?

¿Debería usar object == null sobre Objects.isNull () en una declaración if?

Si observa el código fuente del IsNullmétodo,

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

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

Es lo mismo. No hay diferencia. Para que puedas usarlo de forma segura.

Objects.isNull está diseñado para su uso dentro del filtrado lambda de Java 8.

Es mucho más fácil y claro escribir:

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

que escribir:

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

Dentro de una ifdeclaración, sin embargo, cualquiera funcionará. El uso de == nullprobablemente sea más fácil de leer, pero al final se reducirá a una preferencia de estilo.

Mira la fuente:

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

Para verificar los nullvalores, puede usar:

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

El hecho de que Objects.isNullesté destinado a Predicates no le impide usarlo como se indicó anteriormente.

¿Habría alguna razón / circunstancia por la que debería usar object == null sobre Objects.isNull () en una declaración if ?

Sí, una razón es mantener el código simple. Dentro de si la declaración object == null es clara y bien conocida. No puede dar lugar a ningún mal comportamiento si, por ejemplo, hay un error tipográfico.

Tengo entendido que Objects.isNull () eliminaría la posibilidad de asignar accidentalmente un valor nulo al objeto omitiendo el segundo =.

Si se omite un if (object = null) {}con , no se compilará o generará una advertencia en caso de objeto. En realidad, no hay razón para usar over dentro de la declaración if . Aquí están las dos variantes una al lado de la otra: =BooleanObjects.isNull(object)object == null

if (object == null) {
}

if (Objects.isNull(object)) {
}

¿Debería Objects.isNull () limitarse exclusivamente a predicados?

Se podría decir que sí, se limita exclusivamente a Predicados, aunque no hay ningún obstáculo técnico para utilizarlo en Objects.isNull()todas partes.

Desde el public static boolean isNull(Object obj)javadoc del método:

@apiNote Este método existe para ser utilizado como java.util.function.Predicate, filter (Objects :: isNull)

Entonces, si usa el método como no un predicado, en realidad está usando una expresión más compleja y engorrosa en comparación con la simple object == null.

Aquí hay un fragmento para comparar el beneficio 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();

Semánticamente no hay diferencia, pero para la legibilidad prefiero lo siguiente whatever == null:

import static java.util.Objects.isNull;

// Other stuff...

if(isNull(whatever)) { 

}