Array and type being created

Question

In Java, when I have the following instruction:

int[] ns = new int[5];

the following doubts arise:

1. An object of what type is created?
2. For each value in an index, I call it an instance?

Answer 1

An object of what type is created?

ns will have an object of type array of int and cannot be changed. Note that because it is a type by reference the variable will have a pointer to the real object.

For each value in an index, I call it an instance?

For each value in a location that can be accessed by an index there will be a type instance int. Because it is a type by value, the instance is already right there in the variable, that is, in the variable ns[0] will have a 4 bytes integer, in ns[1] also, and so on.

System.out.println(1);
System.out.println("x");
System.out.println(new Object());
System.out.println(new ArrayList());

I put in the Github for future reference.

The first has an instantiated object of type int and it is used to print. The object originally is in the static part of the code. When called the method println() a copy of it is passed as argument, so the parameter will receive a new instance of int identical to the original. We are sure it is a new instance because the argument value could change smoothly (in this case it does not change because it is a constant) and would not affect the value being used within println(), after all are two completely different instances. There is an instance, is an object, based on primitive type. I will not go into the detail that some implementation may require to do Boxing and the value be copied to the heap, which is inefficient.

The second is very similar. What many people don’t understand is that the literal string is actually a new String("x"). The guy string looks like a primitive type because it has value semantics, but in fact it is a type by reference. It will probably be allocated in the heap because of the new, but this is not guaranteed, there can be an optimization and be allocated in the stack (this is just implementation details). Note that in this case there will not even be a de facto allocation, because the string will be in the static part of the code and the required reference will point to this address.

The third creates an object by reference, probably allocated in the heap, and he’s kind of Object. Since there is no structure in it, the allocation will be empty (but it consumes memory space anyway (if I’m not mistaken 20 bytes).

The fourth creates an object in the same way, and it will be derived from Object. Don’t confuse Object with Object. One is a word we use to designate presumably material things, the other is the name of a root class used in some object-oriented languages, as is the case with Java.

Behold Memory allocation in C# - Value types and reference types. In Java it’s the same.