"" + null is "null"

Aren't you glad Java doesn't allow operator overloading, so this sort of mischief is impossible? /s

You're kidding, surely? Java really does that?

"" + null should be null (or throw an exception). Null is null and nothing else.

Nobody writes "" + null. They write "" + myVariableRef. And myVariableRef is null. As I posted earlier, the code is compiled to "" + String.valueOf(myVariableRef).

Since the empty String is a valid String, and Strinfg.valueOf() also returns a String, what other behavior would you ever imagine being sane or possible?

> Since the empty String is a valid String, and Strinfg.valueOf() also returns a String, what other behavior would you ever imagine being sane or possible?

IMHO, String.valueOf() throwing NPE upon encountering a null reference would be both sane and possible.

Unfortunately, it does indeed appear that it returns "null" instead [1].

[1] https://docs.oracle.com/javase/7/docs/api/java/lang/String.h...

On the other hand, it's quite convenient to not have to do null checks in debug messages. Compare:

log.trace("doStuff(" + obj1 + ", " + obj2 + ")");

to this:

log.trace("doStuff(" + (obj1 != null ? obj1 : "null") + ", " + (obj2 != null ? obj2 : "null") + ")");

The second one is IMHO quite hard to read, even in this short example (and code readability is important when you do code reviews)

That is why you should use string formatting instead of concatenation.

For string formatting, rendering "null" (or "") makes sense; for coercion not.

That just resolves into everyone always doing formatting, and never doing concatenation, which yields the same problem.

It should just throw NPE. I understand why people writing quick debug printlns could be infuriated by that, but the way it works now leads to much more subtle bugs.

An empty string of it HAS to be a string would make infinitely more sense. However a type error wouldn't toady on a strongly typed language

I think it should be an exception as those types can not be concatenated.

But still , "" + null being "null" is just plain crazy. I could see "" + null == "" (as you are concatenating nothing to the string), or "" + null == null as you are concatenating a string to null, but "null" is bonkers.

This is why I shrug when people complain about JavaScript casting weirdnesses

The + operator in this case is compiled to call String.valueOf() which returns "null" when given null.

Not kidding.

http://docs.oracle.com/javase/6/docs/api/java/lang/String.ht...

http://stackoverflow.com/questions/4260723/concatenating-nul...

Should have been "during" but I cannot edit my comment so I suppose that typo will live in prosperity.

Posterity?

That's the joke