Dove viene definita la proprietà length dell'array?

Possiamo determinare la lunghezza di un ArrayList<E>usando il suo metodo pubblico size(), come

ArrayList<Integer> arr = new ArrayList(10);
int size = arr.size();

Allo stesso modo possiamo determinare la lunghezza di un Arrayoggetto usando la lengthproprietà

String[] str = new String[10];
int size =  str.length;

Considerando che il size()metodo di ArrayListè definito all'interno della ArrayListclasse, dov'è questa lengthproprietà di Arraydefined?

Le matrici sono oggetti speciali in Java, hanno un attributo semplice chiamato lengthche è final.

Non esiste una "definizione di classe" di un array (non è possibile trovarlo in alcun file .class), fanno parte del linguaggio stesso.

10.7. Membri dell'array

I membri di un tipo di array sono tutti i seguenti:

• Il public finalcampo length, che contiene il numero di componenti dell'array. lengthpuò essere positivo o zero.

• Il publicmetodo clone, che sostituisce il metodo con lo stesso nome in classe Objecte non genera eccezioni verificate. Il tipo restituito del clonemetodo di un tipo di array T[]è T[].

  Un clone di un array multidimensionale è superficiale, vale a dire che crea solo un singolo nuovo array. I subarray sono condivisi.

• Tutti i membri ereditati dalla classe Object; l'unico metodo Objectche non è ereditato è il suo clonemetodo.

risorse:

• JLS - Array

E ' "speciale" in fondo, con la propria istruzione bytecode: arraylength. Quindi questo metodo:

public static void main(String[] args) {
    int x = args.length;
}

viene compilato in bytecode in questo modo:

public static void main(java.lang.String[]);
  Code:
   0:   aload_0
   1:   arraylength
   2:   istore_1
   3:   return

Quindi non si accede come se fosse un campo normale. Infatti, se provi a ottenerlo come se fosse un campo normale, come questo, fallisce:

// Fails...
Field field = args.getClass().getField("length");
System.out.println(field.get(args));

Quindi, sfortunatamente, la descrizione JLS di ogni tipo di array con un campo finale pubblico lengthè in qualche modo fuorviante :(

È definito nelle specifiche del linguaggio Java :

I membri di un tipo di array sono tutti i seguenti:

• Il public finalcampo length, che contiene il numero di componenti dell'array. lengthpuò essere positivo o zero.

Poiché esiste un numero illimitato di tipi di array (per ogni classe esiste un tipo di array corrispondente e quindi esistono array multidimensionali), non possono essere implementati in un file di classe; la JVM deve farlo al volo.

Anche se questa non è una risposta diretta alla domanda, è un'aggiunta all'argomento .lengthvs. .size()Stavo cercando qualcosa correlato a questa domanda, quindi quando mi sono imbattuto ho notato che le definizioni fornite qui

La lunghezza del campo finale pubblico, che contiene il numero di componenti dell'array .

non è "esattamente" corretto.

La lunghezza del campo contiene il numero di posizioni disponibili per inserire un componente, non il numero di componenti presenti nell'array. Quindi rappresenta la memoria disponibile totale allocata a quell'array, non la quantità di memoria occupata.

Esempio:

static class StuffClass {
    int stuff;
    StuffClass(int stuff) {
        this.stuff = stuff;
    }
}

public static void main(String[] args) {

    int[] test = new int[5];
    test[0] = 2;
    test[1] = 33;
    System.out.println("Length of int[]:\t" + test.length);

    String[] test2 = new String[5];
    test2[0] = "2";
    test2[1] = "33";    
    System.out.println("Length of String[]:\t" + test2.length);

    StuffClass[] test3 = new StuffClass[5];
    test3[0] = new StuffClass(2);
    test3[1] = new StuffClass(33);
    System.out.println("Length of StuffClass[]:\t" + test3.length);         
}

Produzione:

Length of int[]:        5
Length of String[]:     5
Length of StuffClass[]: 5

Tuttavia, la .size()proprietà di the ArrayListfornisce il numero di elementi nell'elenco:

ArrayList<Integer> intsList = new ArrayList<Integer>();
System.out.println("List size:\t" + intsList.size());
intsList.add(2);
System.out.println("List size:\t" + intsList.size());
intsList.add(33);
System.out.println("List size:\t" + intsList.size());

Produzione:

List size:  0
List size:  1
List size:  2

è il campo finale pubblico, che contiene il numero di componenti dell'array (la lunghezza può essere positiva o zero)

Un array ha quindi gli stessi campi e metodi pubblici della seguente classe:

class A implements Cloneable, java.io.Serializable {
    public final int length = X;
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e.getMessage());
        }
    }
}

maggiori informazioni su

10.7 Membri dell'array

http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html

Per rispondere così com'è, dov'è definita questa proprietà di lunghezza dell'array ? In uno speciale Object header.

Facile da vedere tramite JOL

 int [] ints = new int[23];
 System.out.println(ClassLayout.parseInstance(ints).toPrintable());

Una delle linee di questo output sarà:

OFFSET  SIZE      TYPE DESCRIPTION
16       4        (object header)   17 00 00 00 (00010111 00000000 00000000 00000000) (23)

Di solito gli oggetti hanno due intestazioni (segno e klass), gli array ne hanno uno in più che occupa sempre 4 bytesin lunghezza, come sizeè un int.

La lunghezza della parola chiave si comporta come un dato archiviato definito. Quando si utilizza in un array, è possibile utilizzarlo per accedere al numero di elementi in un array. Per quanto riguarda String [], possiamo invocare il metodo length () definito nella classe String. Per quanto riguarda ArrayList, possiamo usare il metodo size () definito in ArrayList. Si noti che quando si crea un elenco di array con ArrayList <> (capacità), la dimensione iniziale () di questo elenco di array è zero poiché non è presente alcun elemento.