Creazione di un array di oggetti in Java

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, ad esempio in un argomento del metodo:

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

Sì, crea solo riferimenti, che sono impostati sul loro valore predefinito null. Questo è il motivo per cui si ottiene un NullPointerException È necessario creare oggetti separatamente e assegnare il riferimento. Ci sono 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.

Instantiation – In questo passaggio, creiamo la matrice, o allocare memoria per la matrice, utilizzando la nuova parola chiave. È in questo passaggio che menzioniamo le dimensioni delle dimensioni dell'array.

Inizializzazione – L'array viene sempre inizializzato al valore predefinito del tipo di dati. Ma possiamo fare le nostre inizializzazioni.

Dichiarazione di array in Java

Questo è il modo in cui dichiariamo un array unidimensionale in Java-

int[] array;
int array[];

Oracolo consiglia di utilizzare la sintassi precedente per dichiarare gli array. 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!

Istanziazione

Questo è il modo in cui "istanziiamo" o assegniamo memoria per un array –

int[] array = new int[5];

Quando la JVM incontra la parola chiave new, capisce che deve allocare memoria per qualcosa. E specificando int[5], intendiamo che vogliamo una matrice 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 tipo int[]

Inizializzazione

Utilizzando un ciclo – Utilizzando un ciclo for per inizializzare gli elementi di un array è il modo più comune per ottenere l'array in corso. Non è necessario eseguire un ciclo for se si intende assegnare il valore predefinito stesso, perché 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 la dimensione, perché JVM può vedere che stiamo dando 5 valori.

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

Fonte - Array in Java

Ecco il chiaro esempio di creazione di una matrice di 10 oggetti dipendenti, con un costruttore che prende 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 pieno di elementi forniti da alcuni "factory", dal momento che Java 8 (che introduce stream API) possiamo usare questo one-liner:

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

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

Per alcuni tipi primitivi puoi usare DoubleStream, IntStream, LongStream che forniscono inoltre generatori come range rangeClosed e pochi altri.

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

1. Dichiarare e quindi istanziare (Creare memoria per memorizzare 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 i 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. Ad esempio:

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

Risulta in: "Impossibile creare un array generico"

Utilizzare invece:

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