Develop Reference

Why arrays can be used in the generic in JAVA？ [duplicate]

This question already has answers here:
Primitive arrays as a generic parameter [duplicate]
(4 answers)
Closed 1 year ago.
int is primitive type in java. Why is int[] usable as a generic type?
I can write code like this and compile it.
List<int[]> test = new ArrayList<>();

Indeed int is a primitive however an array of integers, int[], isn't.
Java Docs define an array as,
An array is a container object that holds a fixed number of values of
a single type.
As you can see an array is an object with class hierarchy as following,
java.lang.Object
java.util.Arrays
So arrays in java are basically objects of type java.util.Arrays. The same class also provides all the good operations you can perform on Arrays.
Back to your question, you're right, Java doesn't allow passing primitives as type parameter when you're using generics.
You cannot do this,
List<int> test = new ArrayList<int>();
However you can do generics with Integer class just fine,
List<Integer> test = new ArrayList<Integer>();
The reasons for not allowing primitives are discussed here on stackoverflow.
One might think, Java does support autoboxing so why not simply autobox primitives to their equivalent classes. Well that is a design choice. Primitives are efficient and cost less memory. Designers probably rightly decided to not assume autoboxing would serve equivalent efficiency.

Array of Object in Java vs C++

My Background is C++ and in c++ we can easily create array of object using simple syntax. className obj[n]; and also constructor will call n time.
But When I tried to create array of object in java className[] obj=new className[n]; no constructor call. After searching I found the answer of this question on stackoverflow that it just create n Reference that can point to n objects and I need to create objects again for each reference like. obj[0]=new className();
Now I just want to ask why java do this? is there any reason even C++ allows but java not allows to create array of objects in same way?
I searched for this but still didn't get exact answer.

In C++ you have flexibility to choose a memory in which you create the object. You can create objects in automatic area (on the stack), in the static area, or in the dynamic area. In the last case you get an object pointer, and become responsible for freeing it after you are done.
In contrast, all Java has is the dynamic area option, because all objects are reference objects. In C++ that would be equivalent to using objects only through pointers, and always creating them with new. When you do this in C++, you also have to fill your array of pointers with new-ed objects:
myclass *array[10];
for (int i = 0 ; i != 10 ; i++) {
array[i] = new myclass();
}
...
for (int i = 0 ; i != 10 ; i++) {
delete array[i];
}
Allowing creation of object arrays in C++ was a choice dictated by need to let programmers allocate arrays of objects in the automatic area. It came with a tradeoff, because objects from which you make arrays must have a default constructors. This is not ideal, because the requirement of default constructor sounds arbitrary.
Java, on the other hand, was free from the automatic memory requirement, so they went for a simple solution that requires you to initialize objects individually.

Not so often need you to create objects of the same type as array with default constructor. Sometimes you want to call the custom constructor. Sometimes you want to instantiate the subclasses and store them in the array.
Note that Java array className[] obj is more equivalent to C++ array className* obj[n], not just className obj[n], because it's an array of references to the objects, not the array of objects themselves. As of Java-8 you cannot create an array of objects themselves (they are discussed as part of project Valhalla, but will not appear even in Java-9). When the objects themselves are stored in the array in C++, you must initialize the array. You cannot keep "nulls" or something like this there, because null is not an object, it's the reference (or pointer). When you create className* obj[n] array in C++ (which is more similar to Java className[] obj array), it's uninitialized as well.
Finally note that in Java-8 you can quite easily create all the objects instantiating them with default constructor like this:
className[] array = Stream.generate(className::new).limit(n).toArray(className[]::new);

What is allowed or not do is up to the language designers.
If you want to initialize all elements of an Array with a reference to the same object in Java you can use :
className[] obj = new clasName[2];
Arrays.fill(obj, new className());
or to create different objects and pass different arguments to each constructor
className[] obj = new className[] {new className(), new className()};

In Java, whenever you declare a variable, be it a member of an object or a local variable, it's either of primitive type (byte, char, ...) or of reference-type (pointer to object of some type).
Thus, there are no arrays of objects, only arrays of references.
In C++ you have the freedom and responsibility to choose how many indirections you do, how to allocate, free, construct and destroy objects, adding much complexity:
dereference-operator (*pointer)
dereference-and-use-member (pointer->member)
address-of-operator (&object)
a way to derive a pointer-to-type from other types (type* var).
placement-new (`new(pointer) type(arg1, arg2);
explicit delete-operator (delete pointer)
much more.

Why are arrays Objects, but can not be used as a base class?

The Java language specification specifies that
In the Java programming language arrays are objects (§4.3.1), are dynamically created, and may be assigned to variables of type Object (§4.3.2). All methods of class Object may be invoked on an array.
So, considering arrays are objects — why did the Java designers make the decision not to allow inherit and override from it, for example, toString() or equals()?
The current syntax wouldn't allow creating anonymous classes with an array as the base class, but I don't think that was the reason for their decision.

Java was a compromise between non-object languages and very slow languages of that time where everything was an object (think about Smalltalk).
Even in more recent languages, having a fast structure at the language level for arrays (and usually maps) is considered a strategic goal. Most people wouldn't like the weight of an inheritable object for arrays, and certainly nobody wanted this before JVM advances like JIT.
That's why arrays, while being objects, weren't designed as class instances ("An object is a class instance or an array"). There would be little benefit in having the ability to override a method on an array, and certainly not a great-enough one to counterbalance the need to check for the right method to apply (and in my opinion not a great-one enough to counterbalance the increased difficulty in code reading, similar to what happens when you override operators).

I came across UNDER THE HOOD - Objects and arrays which explains almost anything you need to know about how JVM handles arrays. In JVM, arrays are handled with special bytecodes, not like other objects we are familiar with.
In the JVM instruction set, all objects are instantiated and accessed
with the same set of opcodes, except for arrays. In Java, arrays are
full-fledged objects, and, like any other object in a Java program,
are created dynamically. Array references can be used anywhere a
reference to type Object is called for, and any method of Object can
be invoked on an array. Yet, in the Java virtual machine, arrays are
handled with special bytecodes.
As with any other object, arrays cannot be declared as local
variables; only array references can. Array objects themselves always
contain either an array of primitive types or an array of object
references. If you declare an array of objects, you get an array of
object references. The objects themselves must be explicitly created
with new and assigned to the elements of the array.
Arrays are dynamically created objects, and they serve as a container that hold a (constant) number of objects of the same type. It looks like arrays are not like any other object, and that's why they are treated differently.

I'd like to point out this article. It seems as though arrays and objects follow different opcodes. I can't honestly summarize it more than that however it seems, arrays are simply not treated as Objects like we're normally used to so they don't inherit Object methods.
Full credits to the author of that post as it's a very interesting read, both short & detailed.
Upon further digging into the topic via multiple sources I've decided to give a more elaborate version of my previous answer.
The first thing to note that instantiation of Objects and Arrays are very different within the JVM, their follow their respective bytecode.
Object:
Object instantiation follows a simple Opcode new which is a combination of two operands - indexbyte1 & indexbyte2. Once instantiated the JVM pushes the reference to this object onto the stack. This occurs for all objects irrespective of their types.
Arrays:
Array Opcodes (regarding instantiation of an array) however are divided into three different codes.
newarray - pops length, allocates new array of primitive types of type indicated by atype, pushes objectref of new array
newarray opcode is used when creating arrays that involve primitive datatypes (byte short char int long float double boolean) rather than object references.
anewarray - pops length, allocates a new array of objects of class indicated by indexbyte1 and indexbyte2, pushes objectref of new array
anewarray opcode is used when creating arrays of object references
multianewarray - pops dimensions number of array lengths, allocates a new multidimensional array of class indicated by indexbyte1 and indexbyte2, pushes objectref of new array
multianewarray instruction is used when allocating multi-dimensional arrays
Object can be a class instance or an array.
Take from Oracle Docs
A class instance is explicitly created by a class instance creation expression
BUT
An array is explicitly created by an array creation expression
This goes hand in hand with the information regarding the opcodes. Arrays are simply not developed to be class interfaces but are instead explicitly created by array creation expression thus naturally wouldn't implicitly be able to inherit and/or override Object.
As we have seen, it has nothing to do with the fact that arrays may hold primitive datatypes. After giving it some thought though, it isn't very common to come across situations where one might want to toString() or equals() however was still a very interesting question to try and answer.
Resources:
Oracle-Docs chapter 4.3.1
Oracle-Docs chapter 15.10.1
Artima - UnderTheHood

There are many classes in standard java library that you cannot subclass, arrays aren't the only example. Consider String, or StringBuffer, or any of the "primitive wrappers", like Integer, or Double.
There are optimizations that JVM does based on knowing the exact structure of these objects when it deals with them (like unboxing the primitives, or manipulating array memory at byte level). If you could override anything, it would not be possible, and affect the performance of the programs very badly.

When are array initialized in Java?

When I write this
String[] fruits = {"Apple", "Pear"};
I would expect that at compile time the array and the strings are created, like it would happen for similar code in C. Is it correct? Are array and their content generally created at compile time or at run-time?

Arrays, which are objects in Java, are created. This can only occur at runtime.
Note that many objects are created in a Java program, and your object creations occurs only after the VM itself is initialized. One static array initialization isn't going to put a noticeable burden on your performances.
If you don't change the array and you have many instances, be sure to declare it as static :
static String[] fruits = {"Apple", "Pear"};
Note also an important difference with what could be a statically compiled array : the java array is mutable. You can't change its length but you can change its elements (or nullify them). A java array, even final static, isn't really constant.

Arrays are special objects in java. So, they will be created at runtime.
As per Java Language Specification
In the Java programming language, arrays are objects (§4.3.1), are dynamically created, and may be assigned to variables of type Object (§4.3.2)
JLS 15.10 provides more information on array creation expressions.

In Java, why are arrays objects? Are there any specific reasons?

Is there any reason why an array in Java is an object?

Because the Java Language Specification says so :)
In the Java programming language arrays are objects (§4.3.1), are dynamically created, and may be assigned to variables of type Object (§4.3.2). All methods of class Object may be invoked on an array.
So, unlike C++, Java provides true arrays as first-class objects:
There is a length member.
There is a clone() method which overrides the method of the same name in class Object.
Plus all the members of the class Object.
An exception is thrown if you attempt to access an array out of bounds.
Arrays are instanciated in dynamic memory.

Having arrays be objects means that you can do operations with them (e.g., someArray.count('foo')) instead of just doing it against them (e.g., count(someArray, 'foo')), which leads to more natural syntax.

Another point is that objects are mutable and are passed by reference. In arrays there aren't any fields/methods that you can use to change "properties" of the array, but you sure can mutate the element values. And the benefits of passing arrays by reference are pretty obvious (though functional programmers probably wish Java had immutable lists passed by value).
Edit: forgot to mention. In the period before autoboxing, it was helpful to be able to store arrays in collections, write them to ObjectStreams etc.

Probably because they wanted to get as close as possible to making everything an object. Native types are there for backward compatibility.

So that they get all the benefits thereof:
getHashCode()
toString()
etc.
And arrays aren't 'primitive', so if they can't be primitive, they must be objects.

I'm not sure about the official reason.
However, it makes sense to me that they are objects because operations can be performed on them (such as taking the length) and it made more sense to support these operations as member functions rather than introduce new keywords. Other operations include clone(), the inherited operations of object, etc. Arrays are also hashable and potentially comparable.
This is different from C (and native arrays in C++), where your arrays are essentially pointers to a memory offset.