The issue is that String.valueOf method is overloaded:

• String.valueOf(Object)
• String.valueOf(char[])

Java Specification Language mandates that in these kind of cases, the most specific overload is chosen:

JLS 15.12.2.5 Choosing the Most Specific Method

If more than one member method is both accessible and applicable to a method invocation, it is necessary to choose one to provide the descriptor for the run-time method dispatch. The Java programming language uses the rule that the most specific method is chosen.

A char[] is-an Object, but not all Object is-a char[]. Therefore, char[] is more specific than Object, and as specified by the Java language, the String.valueOf(char[]) overload is chosen in this case.

String.valueOf(char[]) expects the array to be non-null, and since null is given in this case, it then throws NullPointerException.

The easy "fix" is to cast the null explicitly to Object as follows:

System.out.println(String.valueOf((Object) null));
// prints "null"

Related questions

• How does polymorph ambiguity distinction work?
• Which overload will get selected for null in Java?

Moral of the story

There are several important ones:

• Effective Java 2nd Edition, Item 41: Use overloading judiciously
  • Just because you can overload, doesn't mean you should every time
  • They can cause confusion (especially if the methods do wildly different things)
• Using good IDE, you can check which overload is selected at compile time
  • With Eclipse, you can mouse-hover on the above expression and see that indeed, the valueOf(char[]) overload is selected!
• Sometimes you want to explicitly cast null (examples to follow)

See also

• Polymorphism vs Overriding vs Overloading
• Method Overloading. Can you overuse it?

On casting null

There are at least two situations where explicitly casting null to a specific reference type is necessary:

• To select overloading (as given in above example)
• To give null as a single argument to a vararg parameter

A simple example of the latter is the following:

static void vararg(Object... os) {
    System.out.println(os.length);
}

Then, we can have the following:

vararg(null, null, null); // prints "3"
vararg(null, null);       // prints "2"
vararg(null);             // throws NullPointerException!

vararg((Object) null);    // prints "1"

See also

• Java Language Guide/varargs - to understand how it's implemented

Related questions

• Why null cast?
• Difference between double… and double[] in formal parameter type declaration

It's a design choice:

• The author of the String.valueOf chose to allow a null argument (presumably generating the string 'null').
• The author of Decimal.valueOf chose to report a null argument as an error; I would guess the thinking there was better to "fail fast" rather than propagate the null.

To avoid lots of null checks, design your code to avoid null values by e.g. initializing variables where they are declared. If a value of null has to be allowed, address that in one place only by e.g. not calling other code that requires a non-null value.

See e.g. 10 Tips to Handle Null Effectively; a couple of these are specific to Java but most apply to Apex.

You are looking for Objects#toString(java.lang.Object,java.lang.String)

The call

Objects.toString(obj, null)

returns null when object is null.

In statement System.out.println(String.valueOf(null)); there is a call of method public static String valueOf(char data[]), which source code is as follows:

public static String valueOf(char data[]) {
  return new String(data);
}

That is why you get NPE

On the other hand, in statement Object a = null; String as = String.valueOf(a); there is a calls of method public static String valueOf(Object obj), which source code is as follows:

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

That is why you get "null" instead of NPE

A bit of theory from Java Language Specification: 15.12.2.5 Choosing the Most Specific Method

If more than one member method is both accessible and applicable to a method invocation, it is necessary to choose one to provide the descriptor for the run-time method dispatch. The Java programming language uses the rule that the most specific method is chosen.

A char[] is of type Object, but not all Object are of type char[]. Type char[] is more specific than Object and as described in the Java Language Specification, the String.valueOf(char[]) overload is chosen in this case.

EDIT

It is also worth mentioning what Ian Roberts mentioned (in his comment below):

It's important to note that it's a compile error if there is no single overloading that is more specific than all the others - if there were a valueOf(String) method as well as valueOf(Object) and valueOf(char[]) then a call to the untyped String.valueOf(null) would be ambiguous

Because String.valueOf(null) picks the overloaded method with char[] argument, and then fails in the new String(null) constructor. This choice is made at compile time.

If you want to explicitly use the overloaded method with a Object argument, use:

String.valueOf((Object) null)

Note that there is no overloaded method taking a String argument - the one invoked in the first case is taking Object.

To quote the JLS:

15.12.2 Compile-Time Step 2: Determine Method Signature

The second step searches the type determined in the previous step for member methods. This step uses the name of the method and the types of the argument expressions to locate methods that are both accessible and applicable, that is, declarations that can be correctly invoked on the given arguments. There may be more than one such method, in which case the most specific one is chosen. The descriptor (signature plus return type) of the most specific method is one used at run time to perform the method dispatch.

All of the methods are applicable, so we go to:

15.12.2.5 Choosing the Most Specific Method

If more than one member method is both accessible and applicable to a method invocation, it is necessary to choose one to provide the descriptor for the run-time method dispatch. The Java programming language uses the rule that the most specific method is chosen.

The informal intuition is that one method is more specific than another if any invocation handled by the first method could be passed on to the other one without a compile-time type error.

Thanks to polygenelubricants - there are only two overloaded methods accepting an object - char[] and Object - char[] is most specific.

boolean creatok = users.create (Objects.toString(name, ""), Objects.toString(desc, ""));

String.valueOf(null) calls valueOf(char data[]) which in turn calls new String(data) which accesses value.length -> NPE.

String.valueOf(someString) calls valueOf(Object obj) which does return (obj == null) ? "null" : obj.toString();

General note: please use a proper IDE. This was not my "knowledge" writing this question but just me using my IDE for ~1 minute to see which methods will actually be called, I did not even run the code.