How does Arrays work in the ByteCode of Java [duplicate]

Answer 1

An array is an object you can try this yourself by simply assigning an array to an object value. For example:

public Object test(){
  int[] test = new int[5];
  Object obj = test; 
  return obj;
}

If you want to know what an array is on a byte level: the array itself is just pointer to a bit of information on the length of the array, some other information and a pointer to a piece of reserved memory in which you can store the data (sequential memory the size of your array). Accessing the data is a simple matter of looking up the [pointer]+[indexnumber]*[sizeofeachitem] and then you know which piece of memory to look at.

Answer 2

Array types actually are classes! As stored in memory, they enclose their basic class information (including the class information of their containing element if they aren't an array of natives), the number of elements they hold, and following that the actual array data. length in an array object is a final field rather than a method, because arrays never hold a different number of elements.

For other kinds of structures, like Vector, the number of elements in the object can change from moment to moment, so length() must be a method. Likewise with String: even though the String class is immutable, it inherits the length() method from CharSequence; some kinds of CharSequence can be variable in their length, so it is again implemented as a method.

Answer 3

An array is actually a class ,it extends Object like any other class, but its been handled internally by the language for better performance and convenience .As a class it can have fields and methods.

Answer 4

Arrays in java have a class, and are therefore objects. Constructing it is done differntly from "normal" classs. More on that maybe in

Why isn't there a java.lang.Array class? If a java array is an Object, shouldn't it extend Object?

Answer 5

Arrays are objects in Java, but they don't correspond to real classes. Effectively, the JVM implicitly creates array classes on the fly, but for performance reasons, they aren't actual classes.

Since they are objects, they can be stored in Object fields and passed around like normal. However, they are treated a bit differently at the bytecode level.

First off, arrays are created with the newarray, anewarray, or multinewarray instructions for single dimension primative, single dimension object, and multidimensional arrays respectively. By contrast, regular objects are created with the new instruction.

Getting and setting elements is done with the *aload and *astore instructions.

Also, x.length is not a real field. Instead it gets compiled to the arraylength instruction. This can be seen by compiling the following code.

public void test(int size){
    int[] x = new int[size];
    String[] y = new String[size];
    System.out.println(x.length);
    System.out.println(y.length);
}

results in the following bytecode

.method public test : (I)V
    .limit stack 2
    .limit locals 4
    iload_1
    newarray int
    astore_2
    iload_1
    anewarray java/lang/String
    astore_3
    getstatic java/lang/System out Ljava/io/PrintStream;
    aload_2
    arraylength
    invokevirtual java/io/PrintStream println (I)V
    getstatic java/lang/System out Ljava/io/PrintStream;
    aload_3
    arraylength
    invokevirtual java/io/PrintStream println (I)V
    return
.end method

Attempting to access the length field by manually creating bytecode will result in an exception, because the field doesn't actually exist.

.method static public main : ([Ljava/lang/String;)V
    .limit stack 1
    .limit locals 1
    aload_0
    getfield [Ljava/lang/String; length I
    return
.end method

results in

Exception in thread "main" java.lang.VerifyError: Expecting reference to class i
n class ArrayTest at constant pool index 30 in method ArrayTest.main([Ljava/lang
/String;)V
        at java.lang.Class.getDeclaredMethods0(Native Method)
        at java.lang.Class.privateGetDeclaredMethods(Unknown Source)
        at java.lang.Class.getMethod0(Unknown Source)
        at java.lang.Class.getMethod(Unknown Source)
        at sun.launcher.LauncherHelper.getMainMethod(Unknown Source)
        at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)