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

87

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?

Lucas t
fonte
3
Se tudo o que você está se preocupando é uma atribuição acidental, você pode simplesmente usar de forma if(null == variable)consistente ...
Holger
1
@Holder, com qual atribuição acidental você deve se preocupar? Isso é Java. Você obterá um erro de tipo.
Louis Wasserman
1
@LouisWasserman Não se variablefor a Boolean.
Alexis C.
2
@AlexisC, isso seria uma preocupação em um pequeno, minúsculo número de casos: sua variável tem que ser um tipo muito específico, e você tem que fazer um erro de digitação muito específico, e você não pode usar nenhum IDE ou análise de compilador isso indicaria isso para você (como quase todos os IDEs fariam). Estou bastante confortável em não me preocupar com esse caso.
Louis Wasserman
1
No trabalho, tenho visto muitas ocorrências de null == object . Quando perguntei, disseram-me que era para evitar atribuições nulas acidentais. Com base nos comentários e respostas aqui fornecidos, estou inclinado a acreditar que é uma questão de gosto.
Lucas T

Respostas:

79

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.

Suresh Atta
fonte
14
Sim, pode ser usado, mas pode interferir na análise de fluxo local realizada por uma ferramenta. Ou seja, com um simples "==", qualquer análise de fluxo pode ver que a desreferenciação não é boa no branch then, mas é segura em um branch else. Você obterá erros / avisos apropriados ou nada. Com a indireção de chamar isNull (), esse conhecimento pode ser perdido para a ferramenta.
Stephan Herrmann
3
HÁ uma ligeira diferença de desempenho. A verificação de Java para referência nula de objeto versus a chamada de um método estático terá uma diferença. E a leitura é um pouco menos clara do que usar apenas ==, a que todos estamos acostumados.
Kevin M
3
Tem mais uso semântico == nullem if, mas isNull é ótimo para usar em expressões lambda.
Leonardo Ramos Duarte
1
certamente é legítimo, mas não traz nenhum benefício para as operadoras. Portanto, se você trabalha em equipe, use as coisas de acordo com a finalidade pretendida.
Alex Panchenko
74

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.

Craig Taylor
fonte
12

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.

Mena
fonte
1
O que você quer dizer com risco de erro de digitação?
Ashish Lohia
2
@AshishLohia usando em =vez de ==(não compilaria a menos que fosse um Booleanwrapper anulável , seja justo)
Mena
5
O risco de erro de digitação é o problema em C ++ e não em Java se (myObject = null) resultar em erro de compilação. Você deve sempre usar myObject == null sobre null == myObject.
Tomas Marik
1
@TomasMarik conforme mencionado em meu comentário, o risco de erro de digitação é limitado a Booleanwrappers anuláveis em Java. Isso é muito raro (e dará avisos ao compilador quando uma atribuição de nullfor verificada como se fosse uma condição), mas não impossível.
Mena
7

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();
Vasil
fonte
1

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

}
angry_snyder
fonte