Since Java 7 you can use the static method java.util.Objects.equals(Object, Object) to perform equals checks on two objects without caring about them being null.

If both objects are null, it will return true, if one is null and the other isn't, it will return false. Otherwise, it will return the result of calling equals on the first object with the second as argument.

You're not comparing the objects themselves, you're comparing their references.

Try

c != null

in your if statement.

Java 7.0 added a new handy class: Objects.

It has a method exactly for this: Objects.equals(Object a, Object b)

You can simply use Apache Commons Lang:

result = ObjectUtils.compare(firstComparable, secondComparable)

If Java 7+, use Objects.equals(); its documentation explicitly specifies that:

[...] if both arguments are null, true is returned and if exactly one argument is null, false is returned. Otherwise, equality is determined by using the equals method of the first argument.

which is what you want.

If you don't, your method can be rewritten to:

return s1 == null ? s2 == null : s1.equals(s2);

This works because the .equals() contract guarantees that for any object o, o.equals(null) is always false.

The == operator tests whether two variables have identical value. For object references, this means that the variables must refer to the same object (or both variables must be null). The equals() method, of course, requires that the variable on which it is invoked not be null. It's behavior depends on the type of object being referenced (on the actual object, not on the declared type). The default behavior (defined by Object) is to simply use ==.

To get the behavior you want, you can do:

System.out.println(a == null ? b == null : a.equals(b));

NOTE: as of Java 7, you can use:

System.out.println(java.util.Objects.equals(a, b));

which does the same thing internally.

There is new utility class available in jdk since 1.7 that is 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.

You can use Objects.equals, it handles null.

Objects.equals(Object a, Object b) Returns true if the arguments are equal to each other and false otherwise. Consequently, if both arguments are null, true is returned and if exactly one argument is null, false is returned. Otherwise, equality is determined by using the equals method of the first argument.

if(Objects.equals(myString,myString2)){...}

The method you linked to takes in two objects and is a static method. You need to call it like Objects.equals(a, b). Instead you are calling .equals() on a null object which throws NPE

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