Java null verifica por que usar == em vez de .equals ()

Em Java, me disseram que, ao fazer uma verificação nula, deve-se usar == em vez de .equals (). Quais são as razões para isso?

Eles são duas coisas completamente diferentes. == compara a referência do object, se houver, contida por uma variável. .equals() verifica se dois objects são iguais de acordo com seu contrato para o que igualdade significa. É totalmente possível que duas instâncias de objects distintos sejam “iguais” de acordo com seu contrato. E depois há o pequeno detalhe de que, como equals é um método, se você tentar invocá-lo em uma referência null , obterá um NullPointerException .

Por exemplo:

 class Foo { private int data; Foo(int d) { this.data = d; } @Override public boolean equals(Object other) { if (other == null || other.getClass() != this.getClass()) { return false; } return ((Foo)other).data == this.data; } /* In a real class, you'd override `hashCode` here as well */ } Foo f1 = new Foo(5); Foo f2 = new Foo(5); System.out.println(f1 == f2); // outputs false, they're distinct object instances System.out.println(f1.equals(f2)); // outputs true, they're "equal" according to their definition Foo f3 = null; System.out.println(f3 == null); // outputs true, `f3` doesn't have any object reference assigned to it System.out.println(f3.equals(null)); // Throws a NullPointerException, you can't dereference `f3`, it doesn't refer to anything System.out.println(f1.equals(f3)); // Outputs false, since `f1` is a valid instance but `f3` is null, // so one of the first checks inside the `Foo#equals` method will // disallow the equality because it sees that `other` == null 

se você invocar .equals() em null você obterá NullPointerException

Por isso, é sempre aconselhável verificar a nulidade antes de invocar o método, sempre que se aplica

 if(str!=null && str.equals("hi")){ //str contains hi } 

Veja também

  • diferença-entre-iguais e == em Java

No Java 0 ou null são tipos simples e não objects.

O método equals () não é construído para tipos simples. Tipos simples podem ser combinados com ==.

Além da resposta aceita ( https://stackoverflow.com/a/4501084/6276704 ):

Desde o Java 1.7, se você quiser comparar dois objects que podem ser nulos, eu recomendo esta function:

 Objects.equals(onePossibleNull, twoPossibleNull) 

java.util.Objects

Esta class consiste em methods de utilitários estáticos para operar em objects. Esses utilitários incluem methods nulos-seguros ou tolerantes a nulos para calcular o código hash de um object, retornando uma string para um object e comparando dois objects.

Desde: 1,7

 foo.equals(null) 

O que acontece se foo é nulo?

Você recebe um NullPointerException.

Se uma variável Object for nula, não será possível chamar um método equals (), portanto, uma verificação de referência de object de null é adequada.

Se você tentar chamar equals em uma referência de object nulo, obterá uma exceção de ponteiro nulo lançada.

Segundo fonts , não importa o que usar para a implementação do método padrão:

 public boolean equals(Object object) { return this == object; } 

Mas você não pode ter certeza sobre os equals na class personalizada.

Se usarmos o método => .equals

 if(obj.equals(null)) // Which mean null.equals(null) when obj will be null. 

Quando seu obj será nulo, ele lançará a exceção de ponto nulo.

então devemos usar ==

 if(obj == null) 

ele irá comparar as referências.

Como equal é uma function derivada da class Object, esta function compara itens da class. se você usá-lo com null, ele retornará false porque o conteúdo da class cause não é nulo. Além disso == compara a referência a um object.

aqui está um exemplo onde str != null mas str.equals(null) ao usar org.json

  JSONObject jsonObj = new JSONObject("{field :null}"); Object field = jsonObj.get("field"); System.out.println(field != null); // => true System.out.println( field.equals(null)); //=> true System.out.println( field.getClass()); // => org.json.JSONObject$Null 

EDIT: aqui está a class org.json.JSONObject $ Null :

 /** * JSONObject.NULL is equivalent to the value that JavaScript calls null, * whilst Java's null is equivalent to the value that JavaScript calls * undefined. */ private static final class Null { /** * A Null object is equal to the null value and to itself. * * @param object * An object to test for nullness. * @return true if the object parameter is the JSONObject.NULL object or * null. */ @Override public boolean equals(Object object) { return object == null || object == this; } } 

Então eu nunca me confundo e evito problemas com esta solução:

 if(str.trim().length() <=0 ) { // is null ! } 

Você sempre pode fazer

 if (str == null || str.equals(null)) 

Isso primeiro verificará a referência do object e, em seguida, verificará o próprio object, fornecendo a referência isnt null.