Null values of Strings and Integers in Java

public class Test {
    public static void main(String[] args) {

        String s = null;
        String s1 = null;
        Integer i = null;
        Integer i1 = null;

        System.out.println(s+i);
        System.out.println(i+s);
        System.out.println(s+s1);

        try {
            System.out.println(i+i1);
        } catch (NullPointerException np) {         
            System.out.print("NullPointerException");       
        }
    }

}

The question is simple - why do I receive a NullPointerException only at the last line?

Solution 1:

Your code makes use of two different additive operators. The first three lines use string concatenation, whereas the last one uses numeric addition.

String concatenation is well-defined to turn null into "null":

• If the reference is null, it is converted to the string "null" (four ASCII characters n, u, l, l).

Hence there is no NPE.

Adding two Integer objects together requires them to be unboxed. This results in the null reference being dereferenced, which leads to the NPE:

• If r is null, unboxing conversion throws a NullPointerException

Solution 2:

Notice that first three + operator usages involve string concatenation. Only the last one is the actual numeric sum. When string concatenation is involved (where s variable is involved), Java compiler uses some clever trick to improve performance. It replaces + operator with StringBuilder. For example your first line is translated to:

StringBuilder tmp = new StringBuilder();
tmp.append(s);
tmp.append(i);
System.out.println(tmp);

StringBuilder is null-friendly so no matter what you pass as an argument, it nicely replaces it with "null" string.

The situation is different in the last line. There you reference two Integer objects. The only that the JVM can do here is to unbox them (i.intValue()) and do the actual computation. Unboxing of null causes NullPointerException.

Solution 3:

The concatenation (+ operator) of anything with a String results in a String. Every operand is first converted to a String (either using toString(), or using the value "null"), then concatenated.

But the last operation involves Integers only, so the previous rules don't apply. Instead of a concatenation, it does an addition. But to add two Integers, it converts objects (Integers) to primitive values (int), which is not possible if the Integer is null. That's why you get a NullPointerException.

Solution 4:

Seems to be a case of auto-unboxing. If you've got two Integers first and second, then the result of their addition will be first.intValue() + second.intValue(). Since both of them are null, that results in an NPE.