Creazione di una matrice di oggetti in Java

Sono nuovo di Java e per il momento ho creato una serie di oggetti in Java.

Ho una classe A per esempio -

A[] arr = new A[4];

Ma questo sta creando solo puntatori (riferimenti) Ae non 4 oggetti. È corretto? Vedo che quando provo ad accedere a funzioni / variabili negli oggetti creati ottengo un'eccezione puntatore null. Per poter manipolare / accedere agli oggetti ho dovuto fare questo:

A[] arr = new A[4];
for (int i = 0; i < 4; i++) {
    arr[i] = new A();
}

È corretto o sto facendo qualcosa di sbagliato? Se questo è corretto, è davvero strano.

EDIT: lo trovo strano perché in C ++ dici semplicemente nuovo A[4]e crea i quattro oggetti.

Questo è corretto.

A[] a = new A[4];

... crea 4 Ariferimenti, in modo simile al seguente:

A a1;
A a2;
A a3;
A a4;

Ora non puoi fare a a1.someMethod()meno di allocare in a1questo modo:

a1 = new A();

Allo stesso modo, con l'array devi fare questo:

a[0] = new A();

... prima di usarlo.

Questo è corretto. Puoi anche fare:

A[] a = new A[] { new A("args"), new A("other args"), .. };

Questa sintassi può anche essere utilizzata per creare e inizializzare un array ovunque, come in un argomento del metodo:

someMethod( new A[] { new A("args"), new A("other args"), . . } )

Sì, crea solo riferimenti, che sono impostati sul valore predefinito null. Ecco perché ottieni una NullPointerException Devi creare oggetti separatamente e assegnare il riferimento. Esistono 3 passaggi per creare array in Java:

Dichiarazione - In questo passaggio, specifichiamo il tipo di dati e le dimensioni dell'array che stiamo per creare. Ma ricorda, non menzioniamo ancora le dimensioni delle dimensioni. Sono lasciati vuoti.

Istantanea : in questo passaggio, creiamo l'array o allociamo la memoria per l'array, utilizzando la nuova parola chiave. È in questo passaggio che citiamo le dimensioni delle dimensioni dell'array.

Inizializzazione : l'array viene sempre inizializzato sul valore predefinito del tipo di dati. Ma possiamo fare le nostre inizializzazioni.

Dichiarare le matrici in Java

Ecco come dichiariamo un array monodimensionale in Java -

int[] array;
int array[];

Oracle consiglia di utilizzare la sintassi precedente per dichiarare le matrici. Ecco alcuni altri esempi di dichiarazioni legali -

// One Dimensional Arrays
int[] intArray;             // Good
double[] doubleArray;

// One Dimensional Arrays
byte byteArray[];           // Ugly!
long longArray[];

// Two Dimensional Arrays
int[][] int2DArray;         // Good
double[][] double2DArray;

// Two Dimensional Arrays
byte[] byte2DArray[];       // Ugly
long[] long2DArray[];

E questi sono alcuni esempi di dichiarazioni illegali -

int[5] intArray;       // Don't mention size!
double{} doubleArray;  // Square Brackets please!

la creazione di istanze

Questo è il modo in cui "istanziamo" o allochiamo memoria per un array -

int[] array = new int[5];

Quando JVM incontra la newparola chiave, capisce che deve allocare memoria per qualcosa. E specificando int[5], intendiamo che vogliamo un array di ints, di dimensione 5. Quindi, la JVM crea la memoria e assegna il riferimento della memoria appena allocata all'array che un "riferimento" di tipoint[]

Inizializzazione

Uso di un ciclo : l'utilizzo di un ciclo for per inizializzare gli elementi di un array è il modo più comune per avviare l'array. Non è necessario eseguire un ciclo for se si intende assegnare il valore predefinito stesso, poiché JVM lo fa per te.

Tutto in uno..! - Possiamo dichiarare, istanziare e inizializzare il nostro array in una volta sola. Ecco la sintassi -

int[] arr = {1, 2, 3, 4, 5};

Qui, non menzioniamo le dimensioni, perché JVM può vedere che stiamo dando 5 valori.

Quindi, fino a quando non creeremo un'istanza, i riferimenti rimangono nulli. Spero che la mia risposta ti abbia aiutato ..! :)

Sorgente: array in Java

Ecco il chiaro esempio di creazione di array di 10 oggetti dipendenti, con un costruttore che accetta il parametro:

public class MainClass
{  
    public static void main(String args[])
    {
        System.out.println("Hello, World!");
        //step1 : first create array of 10 elements that holds object addresses.
        Emp[] employees = new Emp[10];
        //step2 : now create objects in a loop.
        for(int i=0; i<employees.length; i++){
            employees[i] = new Emp(i+1);//this will call constructor.
        }
    }
}

class Emp{
    int eno;
    public Emp(int no){
        eno = no;
        System.out.println("emp constructor called..eno is.."+eno);
    }
}

Hai ragione. A parte questo, se vogliamo creare un array di dimensioni specifiche riempito con elementi forniti da alcuni "factory", dal momento che Java 8 (che introduce l' API stream ) possiamo usare questo one-liner:

A[] a = Stream.generate(() -> new A()).limit(4).toArray(A[]::new);

• Stream.generate(() -> new A())è come una fabbrica per elementi A separati creati in un modo descritto da lambda, () -> new A()che è implementazione di Supplier<A>- descrive come ogni nuova istanza A dovrebbe essere creata.
• limit(4)imposta la quantità di elementi che lo stream genererà
• toArray(A[]::new)(può anche essere riscritto come toArray(size -> new A[size])): ci consente di decidere / descrivere il tipo di array che dovrebbe essere restituito.

Per alcuni tipi primitivi che è possibile utilizzare DoubleStream, IntStream, LongStreamche forniscono inoltre i generatori come range rangeClosede pochi altri.

Sì, è corretto in Java ci sono diversi passaggi per creare una matrice di oggetti:

1. Dichiarazione e quindi istanziazione (creare memoria per archiviare oggetti "4"):

   A[ ] arr = new A[4];

2. Inizializzazione degli oggetti (in questo caso è possibile inizializzare 4 oggetti di classe A)

   arr[0] = new A();
   arr[1] = new A();
   arr[2] = new A();
   arr[3] = new A();

   o

   for( int i=0; i<4; i++ )
     arr[i] = new A();

Ora puoi iniziare a chiamare metodi esistenti dagli oggetti che hai appena creato, ecc.

Per esempio:

  int x = arr[1].getNumber();

o

  arr[1].setNumber(x);

Per la classe generica è necessario creare una classe wrapper. Per esempio:

Set<String>[] sets = new HashSet<>[10]

risultati in: "Impossibile creare un array generico"

Usa invece:

        class SetOfS{public Set<String> set = new HashSet<>();}
        SetOfS[] sets = new SetOfS[10];  

Il modulo genarale per dichiarare un nuovo array in Java è il seguente:

type arrayName[] = new type[numberOfElements];

Dove type è un tipo o un oggetto primitivo. numberOfElementsè il numero di elementi che memorizzerete nell'array e questo valore non può cambiare poiché Java non supporta array dinamici (se è necessaria una struttura flessibile e dinamica per contenere oggetti, è possibile che si desideri utilizzare alcune delle raccolte Java).

Consente di inizializzare un array per archiviare gli stipendi di tutti i dipendenti in una piccola azienda di 5 persone:

int salaries[] = new int[5];

Il tipo di array (in questo caso int) si applica a tutti i valori dell'array. Non è possibile mescolare i tipi in un array.

Ora che abbiamo inizializzato la nostra gamma di stipendi, vogliamo inserire alcuni valori. Possiamo farlo sia durante l'inizializzazione in questo modo:

int salaries[] = {50000, 75340, 110500, 98270, 39400};

O per farlo in un momento successivo come questo:

salaries[0] = 50000;
salaries[1] = 75340;
salaries[2] = 110500;
salaries[3] = 98270;
salaries[4] = 39400;

Esempio più visivo di creazione di array:

Per saperne di più sugli array, consulta la guida .