Sorry if this is a double post, google groups wasn't responding.

If you know that a != null, you can just do a.equal(b). alternatively
you can do:

if (a == b || (a != null && a.equal(b))) {
 // stuff.
}

That works for any combination of a=null and b=null.

Not with strings particularly, but in many other circumstances I find logic
like the above handy.  .NET defines a static method on Object that amounts
to

   public static boolean equals(Object o1, Object o2)
   {
       return (o1 == o2) || (o1 != null && o1.equals(o2))
   }

It would be nice (and backward-compatible) if Java did the same.

One thing nobody mentioned: string interning. If you don't mind the
likelihood that it will never be garbage collected, you can do

stringRef = stringRef.intern();

and all occasions of the same String (same sequence of characters)
being interned will return references to a single String object with
that content. Which means references that are all return values of
intern can be tested for equality using ==. You can also test them
against literals with ==, because string literals are automatically
interned, and the literal becomes a reference to the interned value at
run time.

(This still doesn't help you when you want case-insensitive equality,
though.)

Another thing you could do is put a static method in a utility class
like:

boolean equal (Object x, Object y) {
 if (x == y) return true;
 if (x == null) return y == null;
 if (y == null) return false;
 return x.equals(y);
}

This should work for any pair of references period, extra-efficiently
for interned strings and when one or both references is null, and even
if someone's equals method is poorly implemented and throws NPE when
the argument is null. (If you're confident this won't happen you can
dump the if (y == null) line. You might also dump it and wrap the
return in try { ... } catch (NPE e) { return false; }.)

You can then just write the likes of:

if (equal(x, y)) {
 actionA();
} else {
 actionB();
}

Immutable value objects are natural candidates for providing interning
ability for. This can be done with a static WeakHashMap whose keys are
the interned values and whose values are explicit WeakReferences to
same. The intern() method would look up "this" in the map, and:

private static WeakHashMap<MyClass, WeakReference<MyClass>>
theStaticWeakHashMap = new WeakHashMap<MyClass,
WeakReference<MyClass>>();

public MyClass intern () {
   synchronized (theStaticWeakHashMap) {
       WeakReference<MyClass> result1 =
theStaticWeakHashMap.get(this);
       if (result1 != null) {
           MyClass result2 = result1.get();
           if (result2 != null) return result2;
       }
       theStaticWeakHashMap.put(this, new
WeakReference<MyClass>(this));
       return this;
   }
}

* Interned objects are eligible for garbage collection with this
scheme.
* It is thread-safe.
* It works properly even if the object is garbage collected AFTER the
map get() and BEFORE the WeakReference get().
* It does of course require that MyClass properly implement equals()
and hashCode().

Adding this to a third-party class isn't difficult since you can
create a new class with a static WeakHashMap and an intern(Foo)
method. You can even make a generic interner whose instances have a
(non-static!) WeakHashMap<T, WeakReference<T>> and an intern(T)
method. Trickier is a generic, static interner; it will need a
Class<T> parameter to a parametrized static method, and some unchecked
casts due do using a non-generic WeakHashMap or a WeakHashMap<Object,
WeakReference<Object>>.