Serie di oggetti in Java

Che cos'è un array di oggetti in Java?

A Java serie di oggetti memorizza più istanze di oggetti della stessa classe in un singolo contenitore di dimensioni fisse. A differenza di un array primitivo che memorizza valori come int, double, o boolean direttamente in ogni slot, una serie di oggetti memorizza Riferimenti. Ogni slot punta alla posizione di memoria di un oggetto e l'oggetto stesso risiede su Java mucchio.

Questo layout corrisponde al modo in cui qualsiasi oggetto variabile in Java Funziona. L'array raggruppa semplicemente diversi riferimenti a oggetti in modo da poterli accedere tramite indice. È la scelta naturale quando il numero di oggetti è noto in anticipo e non cambia durante il ciclo di vita del programma.

Sintassi

ClassName[] obj = new ClassName[array_length];

Il lato destro assegna spazio per array_length riferimenti, tutti inizializzati a null. Nessun oggetto di ClassName esiste ancora, solo il contenitore che può contenere riferimenti a tali oggetti.

Come creare un array di oggetti in Java

La creazione di un array di oggetti funzionante richiede sempre due fasi di allocazione. La prima alloca il contenitore di riferimento e la seconda alloca ciascun oggetto a cui il contenitore punterà.ping Il secondo passo è la fonte più comune di NullPointerException in principiante Java codice.

Passo 1) Apri il tuo editor di codice e copia il seguente codice:

class ObjectArray {
    public static void main(String args[]) {
        Account obj[] = new Account[2];
        // obj[0] = new Account();
        // obj[1] = new Account();
        obj[0].setData(1, 2);
        obj[1].setData(3, 4);
        System.out.println("For Array Element 0");
        obj[0].showData();
        System.out.println("For Array Element 1");
        obj[1].showData();
    }
}

class Account {
    int a;
    int b;

    public void setData(int c, int d) {
        a = c;
        b = d;
    }

    public void showData() {
        System.out.println("Value of a = " + a);
        System.out.println("Value of b = " + b);
    }
}

Passo 2) Salvare il file come ObjectArray.java, quindi compilalo ed eseguilo.

Passo 3) Prendi nota dell'errore. Prova a risolverlo prima di procedere al passaggio 4.

Passo 4) Ispezionare la linea Account obj[] = new Account[2];. Alloca un array di due variabili di riferimento di tipo Accountma non assegna alcuno Account oggetti. Entrambi gli slot contengono nulle chiamando obj[0].setData(...) su una null il riferimento lancia un NullPointerException in fase di esecuzione.

Passo 5) Rimuovi il commento dalle righe 4 e 5. Queste due righe creano un vero Account oggetti e assegnarli a obj[0] and obj[1]L'array ora contiene riferimenti reali e il codice viene eseguito correttamente.

Produzione:

For Array Element 0
Value of a = 1
Value of b = 2
For Array Element 1
Value of a = 3
Value of b = 4

Come inizializzare un array di oggetti in Java

Oltre all'inizializzazione tramite metodi setter mostrata sopra, un array di oggetti può essere inizializzato in tre modi più eleganti. Ogni stile privilegia la chiarezza alla prolissità, quindi scegli quello più adatto alla situazione.

1. Inizializzazione del ciclo — allocare l'array, quindi scorrere ogni indice e assegnare un nuovo oggetto. Questo è lo schema standard per array di grandi dimensioni o quando il numero di oggetti è dinamico.
2. Inizializzazione del costruttore — Passa i valori direttamente al costruttore al momento della creazione, quindi non è necessaria una chiamata separata al metodo setter.
3. Inizializzazione di array letterali — dichiarare e popolare in un'unica istruzione con un inline { ... } Inizializzatore, ideale per piccoli set fissi.

class Account {
    int a, b;

    public Account(int a, int b) {   // constructor
        this.a = a;
        this.b = b;
    }
}

public class InitDemo {
    public static void main(String[] args) {

        // 1) Loop initialisation
        Account[] loopArr = new Account[3];
        for (int i = 0; i < loopArr.length; i++) {
            loopArr[i] = new Account(i, i * 10);
        }

        // 2) Constructor initialisation, one slot at a time
        Account[] ctorArr = new Account[2];
        ctorArr[0] = new Account(1, 2);
        ctorArr[1] = new Account(3, 4);

        // 3) Array literal initialisation
        Account[] litArr = {
            new Account(5, 6),
            new Account(7, 8),
            new Account(9, 10)
        };

        System.out.println("loop size   = " + loopArr.length);
        System.out.println("ctor size   = " + ctorArr.length);
        System.out.println("literal size= " + litArr.length);
    }
}

L'inizializzazione del ciclo è l'impostazione predefinita più sicura perché garantisce che non venga lasciato alcuno slot nullL'inizializzazione tramite costruttore rende esplicito l'intento quando ogni oggetto necessita di argomenti diversi, e i letterali di array mantengono compatto il codice di esempio. Non mescolare stili all'interno dello stesso array a meno che non ci sia un motivo: la coerenza rende più facile individuare i bug.

Iterazione e accesso agli elementi in un Java Matrice di oggetti

Una volta popolato un array di oggetti, tre modelli coprono quasi tutte le esigenze di accesso. Scegli lo stile di ciclo che meglio si adatta al livello di controllo di cui il codice ha bisogno sull'indice.

Classici - Classic for loop Consente l'accesso all'indice, utile per sostituire elementi, confrontare elementi adiacenti o iterare un sottointervallo.

for (int i = 0; i < obj.length; i++) {
    System.out.println("Element " + i);
    obj[i].showData();
}

Migliorata for loop (il ciclo “for-each”) nasconde l’indice e rende la lettura più naturale quando l’indice non è necessario:

for (Account acc : obj) {
    acc.showData();
}

Flussi (Java 8 e successivi) convertire l'array in una pipeline, utile per filtrare, mappareping, oppure aggregando senza scrivere un ciclo:

import java.util.Arrays;

Arrays.stream(obj)
      .filter(acc -> acc.a > 0)
      .forEach(Account::showData);

Per leggere o aggiornare un singolo elemento, utilizzare l'accesso diretto all'indice, ad esempio obj[1].setData(10, 20). Controlla sempre prima la lunghezza con obj.length per evitare ArrayIndexOutOfBoundsException. Quando qualsiasi slot potrebbe essere null, proteggere l'accesso con un controllo nullo o un Optional per mantenere il programma in esecuzione anziché bloccarsi.

Array di oggetti vs ArrayList di oggetti in Java

Un array di oggetti semplice è veloce e prevedibile, ma la sua dimensione fissa diventa un limite non appena il numero di oggetti cambia durante l'esecuzione. Java'S Quadro delle raccolte fornisce ArrayList come alternativa dinamica. La tabella seguente evidenzia quando ciascuna scelta è appropriata.

Utilizza un array quando un ingombro di memoria ridotto e un'indicizzazione prevedibile sono importanti, ad esempio nei layout a matrice o nei percorsi critici per le prestazioni. Utilizza ArrayList nella maggior parte del codice delle applicazioni di uso quotidiano, perché la possibilità di aggiungere e rimuovere senza riallocazione compensa il piccolo overhead per elemento.

DOMANDE FREQUENTI