Java中的引用变量是否具有任何大小？

Question

In C++ we used sizeof() operator, which function can we use in Java to check the size of an object?

My basic doubt is that whether the reference variable in java has any size or not. Consider the following example:

SampleClass obj = new SampleClass();

Here, will obj have any size? If yes, How can we check it in Java?

Answer 1

obj is a variable, not an object. The value of obj is a reference - which is likely to be 4 or 8 bytes, depending on the JVM.

The size of the object that the value refers to is also JVM-dependent. As several objects can refer to each other, it's generally tricky to talk about the size of an object in Java in any particularly useful way... what usually matters is how much more memory would be potentially available if a particular object became eligible for garbage collection, and that depends on what other objects the first object refers to - and whether there are other objects that refer to those, too.

Obviously the "raw" size of an object is somewhat important too, and at least somewhat easier to predict (to an approximation, at least), but it's still VM-specific and can't easily be requested at execution time. (You could create millions of objects, prevent them from being garbage collected, and measure memory differences, but that's the closest I know of, at least outside a debugger API.)

Answer 2

Since you found my comment superb, I just had to post it as an answer, although it may be superflous to the already existing answers:

Rest assured that a reference variable (like obj ) has a size, although there won't be a platform-independent answer on how large this size is, but there definitely should be a size. But due to this platform (or JVM) dependence, Java is not the language to mess with such low-level details.

Maybe the compiler can optimize some reference variables away as being just aliases for others, but in general obj has to have a size, as it has to somehow store the reference (whatever this is, it is something and not nothing).

Answer 3

obj is only the reference to an instance of SampleClass .

The size that the instance of SampleClass occupies in the memory depends on the elements the files of the object, and VM. But even a reference need some memory of course (like in c)

But the java memory model is much more complicated. If you are really interessted in how much memory the object need, then I strongly recommend to use a memory analyzer.

Anyway: because java is a VM and the Java VM has the garbage collector, there is no real 1:1 relation ship between the size of the memory you would expect by counting the (living) java objects and the memory the VM allocates from the Operation System.

Answer 4

You might try getting some insight on the "size" of the reference by using the freeMemory method of the Runtime class. For example, allocate an array of 1000000 null references:

SampleClass[] array = new SampleClass[1000000];

Check the free memory before and after; the difference may give a hint on what you want to know (the array itself is an object, though its size is probably much less than 1000000, so the measurement must be pretty precise).