Java null check why use == instead of .equals()

问题:

In Java I am told that when doing a null check one should use == instead of .equals(). What are the reasons for this?

回答1:

They\'re two completely different things. == compares the object reference, if any, contained by a variable. .equals() checks to see if two objects are equal according to their contract for what equality means. It\'s entirely possible for two distinct object instances to be \"equal\" according to their contract. And then there\'s the minor detail that since equals is a method, if you try to invoke it on a null reference, you\'ll get a NullPointerException.

For instance:

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

回答2:

if you invoke .equals() on null you will get NullPointerException

So it is always advisble to check nullity before invoking method where ever it applies

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

Also See

• difference-between-equals-and == in Java

回答3:

In Java 0 or null are simple types and not objects.

The method equals() is not built for simple types. Simple types can be matched with ==.

回答4:

In addition to the accepted answer (https://stackoverflow.com/a/4501084/6276704):

Since Java 1.7, if you want to compare two Objects which might be null, I recommend this function:

Objects.equals(onePossibleNull, twoPossibleNull)

java.util.Objects

This class consists of static utility methods for operating on objects. These utilities include null-safe or null-tolerant methods for computing the hash code of an object, returning a string for an object, and comparing two objects.

Since: 1.7

回答5:

foo.equals(null)

What happens if foo is null?

You get a NullPointerException.

回答6:

If an Object variable is null, one cannot call an equals() method upon it, thus an object reference check of null is proper.

回答7:

If you try calling equals on a null object reference, then you\'ll get a null pointer exception thrown.

回答8:

According to sources it doesn\'t matter what to use for default method implementation:

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

But you can\'t be sure about equals in custom class.

回答9:

If we use=> .equals method

if(obj.equals(null))  

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

When your obj will be null it will throw Null Point Exception.

so we should use ==

if(obj == null)

it will compare the references.

回答10:

Because equal is a function derived from Object class, this function compares items of the class. if you use it with null it will return false cause cause class content is not null. In addition == compares reference to an object.

回答11:

here is an example where str != null but str.equals(null) when using 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: here is the org.json.JSONObject$Null class:

/**
 * 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;
    }  
}

回答12:

So I never get confused and avoid problems with this solution:

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

回答13:

You could always do

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

This will first check the object reference and then check the object itself providing the reference isnt null.