Création d'un tableau d'objets en Java

Ceci est correct. Vous pouvez également faire:

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

Cette syntaxe peut également être utilisée pour créer et initialiser un tableau n'importe où, comme dans un argument de méthode:

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

Oui, il ne crée que des références, qui sont définies sur leur valeur par défaut null. C'est pourquoi vous obtenez une NullPointerException Vous devez créer des objets séparément et attribuer la référence. Il y a 3 étapes pour créer des tableaux en Java -

Déclaration – Dans cette étape, nous spécifions le type de données et les dimensions du tableau que nous allons créer. Mais rappelez-vous, nous ne mentionnons pas encore les tailles de dimensions. Ils sont laissés vides.

Instanciation – Dans cette étape, nous créons le tableau, ou allouons de la mémoire pour le tableau, en utilisant le nouveau mot-clé. C'est dans cette étape que nous mentionnons les tailles des dimensions du tableau.

Initialisation – Le tableau est toujours initialisé à la valeur par défaut du type de données. Mais nous pouvons faire nos propres initialisations.

Déclarer Des Tableaux En Java

Voici comment nous déclarons un tableau unidimensionnel en Java -

int[] array;
int array[];

Oracle recommande d'utiliser l'ancienne syntaxe pour déclarer les tableaux. Voici quelques autres exemples de déclarations légales –

// 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[];

Et ce sont quelques exemples de déclarations illégales -

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

Instanciation

C'est ainsi que nous "instancions", ou allouons de la mémoire pour un tableau –

int[] array = new int[5];

Lorsque la JVM rencontre le mot-clé new, elle comprend qu'elle doit allouer de la mémoire pour quelque chose. Et en spécifiant int[5], nous voulons dire que nous voulons un tableau de ints, de taille 5. Ainsi, la JVM crée la mémoire et affecte la référence de la mémoire nouvellement allouée au tableau qui est une "référence" de type int[]

Initialisation

Utilisation d'une boucle – L'utilisation d'une boucle for pour initialiser les éléments d'un tableau est le moyen le plus courant de faire fonctionner le tableau. Il n'est pas nécessaire d'exécuter une boucle for si vous allez attribuer la valeur par défaut elle-même, car JVM le fait pour vous.

Tout en Un..! - Nous pouvons Déclarez, Instanciez et Initialisez notre tableau en une seule fois. Voici la syntaxe -

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

Ici, nous ne mentionnons pas la taille, car JVM peut voir que nous donnons 5 valeurs.

Donc, jusqu'à ce que nous instancions les références restent nulles. J'espère que ma réponse vous a aidé..! :)

Source - Tableaux en Java

Voici l'exemple clair de la création d'un tableau de 10 objets employés, avec un constructeur qui prend le paramètre:

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);
    }
}

Vous avez raison. En dehors de cela, si nous voulons créer un tableau de taille spécifique rempli d'éléments fournis par une "usine", depuis Java 8 (qui introduit stream API), nous pouvons utiliser ce one-liner:

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

• Stream.generate(() -> new A()) est comme factory pour les éléments A séparés créés d'une manière décrite par lambda, () -> new A() qui est l'implémentation de Supplier<A> - il décrit comment chaque nouvelle instance A doit être créée.
• limit(4) définit la quantité d'éléments dont le flux générer
• toArray(A[]::new) (peut également être réécrit comme toArray(size -> new A[size])) - il nous permet de décider/décrire le type de tableau qui doit être retourné.

Pour certains types primitifs, vous pouvez utiliser DoubleStream, IntStream, LongStream qui fournissent en outre des générateurs comme range rangeClosed et peu d'autres.

Oui, c'est correct en Java il y a plusieurs étapes pour faire un tableau d'objets:

1. Déclarer puis Instancier (Créer de la mémoire pour stocker '4' objets):

   A[ ] arr = new A[4];
   

2. Initialisation des Objets (Dans ce cas, vous pouvez initialiser 4 objets de classe A)

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

   Ou

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

Maintenant, vous pouvez commencer à appeler des méthodes existantes à partir des objets que vous venez de créer, etc.

Par exemple:

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

Ou

  arr[1].setNumber(x);

Pour la classe générique, il est nécessaire de créer une classe wrapper. Par exemple:

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

Se traduit par: "Impossible de créer un tableau générique"

Utilisez plutôt:

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