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 class A per esempio –

A[] arr = new A[4]; 

Ma questo è solo la creazione di puntatori (riferimenti) ad A e non a 4 oggetti. È corretto? Vedo che quando provo ad accedere a funzioni / variabili negli oggetti creati ottengo un’eccezione di puntatore nullo. Per essere in grado di manipolare / accedere agli oggetti ho dovuto farlo –

 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: Trovo strano questo perché in C ++ tu dici solo una nuova A [4] e crea i quattro oggetti.

Questo è corretto.

 A[] a = new A[4]; 

crea 4 riferimenti A, simili a questo

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

ora non puoi fare a1.someMethod () senza allocare a1 come

 a1 = new A(); 

allo stesso modo, con l’array che devi fare

 a[0] = new A(); 

prima di usarlo.

Questo è corretto. Puoi anche fare:

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

Questa syntax 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. Ecco perché ottieni una NullPointerException. Devi 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 della matrice che stiamo per creare. Ma ricorda, non menzioniamo ancora le dimensioni delle dimensioni. Sono lasciati vuoti.

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

Inizializzazione : la matrice viene sempre inizializzata sul valore predefinito del tipo di dati. Ma possiamo fare le nostre inizializzazioni.

Dichiarazione di matrici in Java

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

 int[] array; int array[]; 

Oracle consiglia di utilizzare la precedente syntax per la dichiarazione degli 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! 

la creazione di istanze

Questo è il modo in cui “istanziamo” o allociamo memoria per un array –

 int[] array = new int[5]; 

Quando JVM rileva la new parola chiave, capisce che deve allocare memoria per qualcosa. E specificando int[5] , intendiamo che vogliamo un array di int s, di dimensione 5. Quindi, JVM crea la memoria e assegna il riferimento della memoria appena allocata all’array che un “riferimento” di tipo int[]

Inizializzazione

Uso di un ciclo – L’uso di un ciclo for per inizializzare elementi di un array è il modo più comune per far funzionare 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 un colpo solo. Ecco la syntax –

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

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

Quindi, finché non istanziamo i riferimenti rimangono nulli. Spero che la mia risposta ti abbia aiutato ..! 🙂

Sorgente – Array in Java

Ecco il chiaro esempio della creazione di una matrice di 10 oggetti dipendenti, con un costruttore che accetta parametri:

 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 

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

 A[] a = Stream.generate(() -> new A()).limit(4).toArray(A[]::new); 
  • Stream.generate(() -> new A()) è come factory per elementi A separati creati in modo descritto da lambda, () -> new A() che è implementazione del Supplier – descrive come ogni nuovo Dovrebbero essere create istanze.
  • limit(4) imposta la quantità di elementi che il stream genererà
  • toArray(A[]::new) (può anche essere riscritto come toArray(size -> new A[size]) ) – ci permette di decidere / descrivere il tipo di array che deve essere restituito.

Per alcuni tipi primitivi è ansible utilizzare 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 è ansible inizializzare 4 oggetti di class 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 class generica è necessario creare una class wrapper. Per esempio:

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

risultati in: “Imansible creare un array generico”

Usa invece:

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