int is a primitive type and it size 4 bytes and Integer is reference type and its size is 16 bytes. In this case, why does it retuyrn 16 bytes for both the values?

Because the ObjectSizeFetcher.getObjectSize(Object) call is autoboxing the int to an Integer.

AFAIK, there is no standard API to measure the size of a primitive type, or a reference. One reason is that the size will depend on where / how it is stored. For example, a byte stored in a (large) byte[] will most likely take less space than a byte stored as a field of an object. And a byte held is a local variable could be different again. (There are issues of packing and alignment to tack account of.)

It is simple to write overloaded methods to return constant minimum size for each primitive types. References are a bit more tricky because the size of a reference depends on whether you are using a 32 or 64 bit JVM, and whether compressed oops are enabled.

An Integer object in Java occupies 16 bytes.

I don't know whether running a 64- vs 32-bit JVM makes a difference. For primitive types, it does not matter. But I can not say for certain how the memory footprint of an object changes (if at all) under a 64-bit system.

You can test this for yourself here:

Java Tip 130: Do you know your data size?

The reason is very simple: efficiency. In multiple ways.

1. Native data types: The closer the data types of a language match the underlying data types of the hardware, the more efficient the language is considered to be. (Not in the sense that your programs will necessarily be efficient, but in the sense that you may, if you really know what you are doing, write code that will run about as efficient as the hardware can run it.) The data types offered by Java correspond to bytes, words, doublewords and quadwords of the most popular hardware out there. That's the most efficient way to go.

2. Unwarranted overhead on 32-bit systems: If the decision had been made to map everything to a fixed-size 64-bit long, this would have imposed a huge penalty on 32-bit architectures that need considerably more clock cycles to perform a 64-bit operation than a 32-bit operation.

3. Memory wastefulness: There is a lot of hardware out there that is not too picky about memory alignment, (the Intel x86 and x64 architectures being examples of that,) so an array of 100 bytes on that hardware can occupy only 100 bytes of memory. However, if you do not have a byte anymore, and you have to use a long instead, the same array will occupy an order of magnitude more memory. And byte arrays are very common.

4. Calculating number sizes: Your notion of determining the size of an integer dynamically depending on how big the number passed in was is too simplistic; there is no single point of "passing in" a number; the calculation of how large a number needs to be has to be performed at runtime, on every single operation that may require a result of a larger size: every time you increment a number, every time you add two numbers, every time you multiply two numbers, etc.

5. Operations on numbers of different sizes: Subsequently, having numbers of potentially different sizes floating around in memory would complicate all operations: Even in order to simply compare two numbers, the runtime would first have to check whether both numbers to be compared are of the same size, and if not, resize the smaller one to match the size of the larger one.

6. Operations that require specific operand sizes: Certain bit-wise operations rely on the integer having a specific size. Having no pre-determined specific size, these operations would have to be emulated.

7. Overhead of polymorphism: Changing the size of a number at runtime essentially means that it has to be polymorphic. This in turn means that it cannot be a fixed-size primitive allocated on the stack, it has to be an object, allocated on the heap. That is terribly inefficient. (Re-read #1 above.)

There are two things you have to take into account here:

1. Overhead for the data itself (int vs. Integer)

2. Overhead for the object reference

So, let's start :)

1. Integer vs. int.

Primitive int is just a 4 bytes value (not 8 bytes as you've written). Integer is an object, which consists of a primitive int value (4 bytes) and object header. Object header can be 8, 12, or 16 bytes depending on the bitness of your JVM and UseCompressedOops flag. Here is Stackoverflow answer that describes the structure of the object header: https://stackoverflow.com/questions/26357186/what-is-in-java-object-header

UseCompressedOops is a flag that makes JVM optimize most of the references on 64-bit JVM and make them take 32 bits instead of 64 bits. If set, it should also make object header take 12 bytes instead of 16 bytes. (To be honest, I didn't measure this).

Given that, the overhead for a bunch of integers will be

number_of_elements * object_header_overhead

, where object_header_overhead =

• 8 bytes (on 32 bit JVM)

• 12 bytes (on 64 bit JVM with UseCompressedOops = true)

• 16 bytes (on 64 bit without compressed oops)

But that's not the end of the story.

2. Size of object reference

int is a primitive, in another words it's just 4 bytes of data, and that's it. Integer is an object, which means it should be referenced from some another place in your program. If it is not referenced from anywhere, it's lost (and soon will be eaten by the GC).

Now, if you have an array of ints, then each element of it is a 4 byte int value. If you have an array of Integers, each element of it will be not Integer, but a reference to Integer object.

The size of an object reference is also can be different on different JVMs:

- 32 bits on 32 bit JVM

- 64 bits on 64 bit JVM

- 32 bits on 64 bit JVM with UseCompressedOops

Now you can calculate total overhead for your specific case. Here are few examples:

1. Say, you run the following code on 32 bit JVM:

i1 = new Integer[100];
i2 = new int[100];

These are just empty arrays. The memory taken by them will be exactly the same, because each element of each array will take 4 bytes (0 int is 4 bytes, and null is 32 bits on 32 bit JVM).

2. Now, say you have 64 bit JVM without compressed oops.

i1 = new Integer[100];
i2 = new int[100];

for (int i = 0; i < 100; i++) {
  i1[i] = i; // implicit boxing: new Integer(i);
  i2[i] = i;
}

Now the memory taken by a single element of Integer array will consist of:

• 4 bytes int value

• 16 bytes - object header

• 8 bytes object reference,

while an element of int array will only take 4 bytes. In total you have (16 + 8) * 100 = 240 bytes.

3. Of course, you can have more complicated situations, for instance (let's say, we have 64 bit JVM again):

i1 = new Integer[100];
i2 = new int[100];

int primInt = 42;
Integer wrappedInt = new Integer(42);

for (int i = 0; i < 100; i++) {
  i1[i] = wrappedInt;
  i2[i] = primInt;
}

As you can see, now every element of Integer array references a single Integer object. So, the total memory overhead will consist of:

• 100 * 4 bytes (4 bytes for primitive int vs. 8 bytes for object reference on 64 bit JVM)

• 20 bytes (size of the single Integer object, consisting of 16 bytes for the header and 4 bytes for the int value).

And couple more things to add:

1. I don't guarantee that the information about the size of object header is 100% correct. This is what I remember about it, so please verify it yourself if you need to.

2. Things can get even more complicated, because Java tends to cache Integers and reuse them. So actual memory of your programs can be less than expected.

The size of primitive data is part of the virtual machine specification, and doesn't change. What will change is the size of object references, from 32 bits to 64. So, the same program will require more memory on a 64 bit JVM. The impact this has depends on your application, but can be significant.

If you can use int do so. If the value can be null or is used as an Object e.g. Generics, use Integer

Usually it doesn't matter which one you use but often int performs slightly better.

In C, the integer(for 32 bit machine) is 32 bit and it ranges from -32768 to +32767.

Wrong. 32-bit signed integer in 2's complement representation has the range -2³¹ to 2³¹-1 which is equal to -2,147,483,648 to 2,147,483,647.