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

Como você sabe, java.util.Objectsé

Esta classe consiste em métodos utilitários estáticos para operar em objetos.

Um desses métodos é Objects.isNull().

Meu entendimento é que Objects.isNull()removeria a chance de atribuir acidentalmente um valor nulo ao objeto, omitindo o segundo =.

No entanto, a nota da API afirma:

Este método existe para ser usado como um Predicado, filtro (Objetos :: isNull)

Haveria algum motivo / circunstância pelo qual eu deveria usar object == nullover Objects.isNull()em uma declaração if ?

Deve Objects.isNull()ser confinado exclusivamente a Predicados?

deve usar object == null sobre Objects.isNull () em uma instrução if?

Se você olhar o código-fonte do IsNullmétodo,

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

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

É o mesmo. Não há diferença. Portanto, você pode usá-lo com segurança.

Objects.isNull destina-se ao uso na filtragem lambda do Java 8.

É muito mais fácil e claro escrever:

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

do que escrever:

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

Em uma ifdeclaração, entretanto, qualquer um dos dois funcionará. O uso de == nullé provavelmente mais fácil de ler, mas no final se resumirá a uma preferência de estilo.

Veja a fonte:

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

Para verificar os nullvalores, você pode usar:

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

O fato de Objects.isNullser destinado a Predicates não o impede de usá-lo como acima.

Haveria alguma razão / circunstância para que eu devesse usar object == null sobre Objects.isNull () em uma instrução if ?

Sim, um dos motivos é manter o código simples. Dentro de if, a declaração object == null é clara e bem conhecida. Isso não pode levar a qualquer mau comportamento se, por exemplo, houver um erro de digitação.

Meu entendimento é que Objects.isNull () removeria a chance de atribuir acidentalmente um valor nulo ao objeto omitindo o segundo =.

Se houver um if (object = null) {}com omitido = não irá compilar ou irá gerar um aviso no caso do Booleanobjeto! Na verdade não há razão para usar Objects.isNull(object)ao longo object == nulldentro de if . Aqui estão as duas variantes lado a lado:

if (object == null) {
}

if (Objects.isNull(object)) {
}

Deve Objects.isNull () ser confinado exclusivamente a Predicados?

Pode-se dizer que sim, está confinado exclusivamente a Predicados, embora não haja nenhum obstáculo técnico para usá-lo em Objects.isNull()todos os lugares.

Do public static boolean isNull(Object obj)javadoc do método:

@apiNoteEste método existe para ser usado como java.util.function.Predicate, filtro (Objects :: isNull)

Portanto, se você usar o método como não um predicado, estará, na verdade, usando uma expressão mais complexa e incômoda do que a simples object == null.

Aqui está um snippet para comparar o benefício 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();

Semanticamente, não há diferença, mas para facilitar a leitura, prefiro o seguinte whatever == null:

import static java.util.Objects.isNull;

// Other stuff...

if(isNull(whatever)) { 

}