Does casting null to an array of objects cost more than casting to an object?

Question

I have the following classes

public void dump(Integer value){
    //do soemthing with value
}
public void dump(Integer[] values){
    //do soemthing with values
}

And I want to call dump(null) , it doesn't matter what I choose to cast to because both work as intended with nulls:

    dump((Integer[]) null);
    dump((Integer) null);

1. Which one is better to use resource wise (less ram, cpu usage)?
2. I would think that java would preallocate 4 bytes for a null Integer and 8 bytes for Double, is this true?
3. What about other (more complicated) objects that are nulled, if no constructor call then how are the nulls stored?

Answer 1

1. Which one is better to use resource wise (less ram, cpu usage)?

It won't make any measurable difference.

2. I would think that java would preallocate 4 bytes for a null Integer and 8 bytes for Double, is this true?

No. Null is null. There is only one format. You are confusing objects and references here. null is a reference. All references are the same size.

What about other (more complicated) objects that are nulled

There is no such thing as 'objects that are nulled'.

if no constructor call then how are the nulls stored?

As nulls.

Answer 2

The type of the cast doesn't affect the memory used by null. In a decompiled class:

aconst_null
checkcast     #4                  // class java/lang/Integer
invokevirtual #5                  // Method dump:(Ljava/lang/Integer;)V

vs

aconst_null
checkcast     #6                  // class "[Ljava/lang/Integer;"
invokevirtual #7                  // Method dump:([Ljava/lang/Integer;)

so both are the same in terms of memory usage.

Answer 3

I believe they cost equal because you do not have actual objects in both cases (neither Integer object, neither Integer[] object, which definitely have different size in memory).

What you have here is just 4-bytes reference which points to nothing as it null. From this point of view there is no difference between type to which you are casting these null-s.

Answer 4

1. No difference.
2. Nope. Java doesn't allocate any space at all for a null object, since null by definition is a reference to no object at all. No object at all takes no space at all. The reference itself will always be 32 or 64 bits long.
3. What do you mean by "stored"? A reference variable holds a pointer value, which is always the same size irrespective of the object to which it points. Regardless of the size of the object, even if a reference points to a non-null value, the reference size is always the same no matter what type it references. It is the size of the address. I haven't looked, but I'll bet that the null reference is a special address value such as 0 that points nowhere by definition.

Casting a reference does not change the reference. It still has the exact same value, bit by bit, that it has without the cast.

The only exception to all this is the 32-bit optimization for 64-bit Java. Normally you'd expect all references in 64-bit Java to be, well, 64 bits long. But you can switch on or off the ability to hold references in 32 bits, if certain assumptions about the program hold. But either way, once the JVM decides how wide a reference is, 32 or 64 bits, that will hold true through the program.

So bottom line, no, casting a reference to some other type has no effect on the memory consumed by the reference.

The memory consumed by the object can go to zero if all references to it fall out of scope or become null.

Answer 5

All reference values (and both boxed Integer and arrays are reference values) have the same representation, so there is no difference in the call at all. If there is a difference in cost, it would be do to the implementation of the function that is called.

Answer 6

1. Which one is better to use resource wise (less ram, cpu usage)?

If you ever need to ask yourself this question, you can always write a simple test.

public class Main {
    private static Integer x = 0;
    private static final int n = 500000000;

    public static void dump(Integer value){
        x += 1;
    }
    public static void dump(Integer[] values){
        x += 1;
    }

    public static void main(String[] args) {
        long t = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            dump((Integer[]) null);
        }
        long array_time = System.currentTimeMillis() - t;
        t = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            dump((Integer) null);
        }
        long int_time = System.currentTimeMillis() - t;
        System.out.println("array_time: " + array_time + " ms");
        System.out.println("int_time: " + int_time + " ms");
    }
}

Output:

array_time: 2578 ms
int_time: 2045 ms

Not a significant difference.