Je suis nouveau sur Java et pour le moment j'ai créé un tableau d'objets en Java.
J'ai une classe A par exemple -
A[] arr = new A[4];
Mais cela ne fait que créer des pointeurs (références) vers A et non 4 objets. Est-ce correct? Je vois que lorsque j'essaie d'accéder à des fonctions/variables dans les objets créés, je reçois une exception de pointeur nul .. Pour pouvoir manipuler/accéder aux objets, je devais le faire -
A[] arr = new A[4];
for( int i=0; i<4; i++ )
arr[i] = new A();
Est-ce correct ou est-ce que je fais quelque chose de mal? Si cela est correct, c'est vraiment étrange.
EDIT: Je trouve cela étrange car en C++, vous dites simplement new A [4] et cela crée les quatre objets.
C'est correct.
A[] a = new A[4];
crée 4 références A, comme pour le faire
A a1;
A a2;
A a3;
A a4;
maintenant vous ne pouvez pas faire a1.someMethod () sans allouer a1 comme
a1 = new A();
de même, avec le tableau que vous devez faire
a[0] = new A();
avant de l'utiliser.
C'est correct. Vous pouvez aussi 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, dont la valeur par défaut est null. C'est pourquoi vous obtenez une exception 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 -
Declaration - 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.
Instantiation - 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.
Initialization - Le tableau est toujours initialisé à la valeur par défaut du type de données. Mais nous pouvons faire nos propres initialisations.
Déclaration de tableaux en Java
Voici comment nous déclarons un tableau unidimensionnel en Java -
int[] array; int array[];
Oracle vous recommande d'utiliser l'ancienne syntaxe pour déclarer des 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 voici quelques exemples de déclarations illégales -
int[5] intArray; // Don't mention size! double{} doubleArray; // Square Brackets please!
Instanciation
Voici comment nous "instancions" ou allouons de la mémoire à un tableau -
int[] array = new int[5];
Lorsque la machine virtuelle Java rencontre le mot clé
new
, elle comprend qu'elle doit allouer de la mémoire pour quelque chose. Et en spécifiantint[5]
, nous voulons dire que nous voulons un tableau deint
s, de taille 5 . Ainsi, la machine virtuelle Java crée la mémoire et affecte la référence de la mémoire nouvellement allouée à un tableau contenant une «référence» de typeint[]
.Initialisation
Utiliser une boucle - Utiliser une boucle for pour initialiser les éléments d'un tableau est le moyen le plus courant de démarrer le tableau. Il n’est pas nécessaire d’exécuter une boucle for si vous voulez attribuer la valeur par défaut elle-même, car JVM le fait pour vous.
Tout en un..! - Nous pouvons déclarer, instancier et initialiser notre tableau en une 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 instanciions 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 d'employé, avec un constructeur qui prend un 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 contenant des éléments fournis par une "fabrique", 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 l’usine pour des éléments A distincts créés de la 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 que le flux va générertoArray(A[]::new)
(peut également être réécrit en tant que toArray(size -> new A[size])
) - cela nous permet de décider/décrire le type de tableau à renvoyer.Pour certains types primitifs, vous pouvez utiliser DoubleStream
, IntStream
, LongStream
qui fournit en outre des générateurs tels que range
rangeClosed
et quelques autres.
Oui, il est correct en Java, il y a plusieurs étapes pour faire un tableau d'objets:
Déclarer puis instancier (créer de la mémoire pour stocker les objets '4'):
A[ ] arr = new A[4];
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();
Vous pouvez maintenant 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);
La forme générale permettant de déclarer un nouveau tableau en Java est la suivante:
type arrayName[] = new type[numberOfElements];
Où type est un type primitif ou un objet. numberOfElements
est le nombre d'éléments que vous allez stocker dans le tableau et cette valeur ne peut pas changer car Java ne prend pas en charge les tableaux dynamiques des collections Java).
Permet d’initialiser un tableau pour stocker les salaires de tous les employés d’une petite entreprise de 5 personnes:
int salaries[] = new int[5];
Le type du tableau (dans ce cas, int
) s'applique à toutes les valeurs du tableau. Vous ne pouvez pas mélanger les types dans un tableau.
Maintenant que nous avons initialisé notre tableau des salaires, nous voulons lui attribuer des valeurs. Nous pouvons le faire soit pendant l'initialisation, comme ceci:
int salaries[] = {50000, 75340, 110500, 98270, 39400};
Ou pour le faire plus tard, comme ceci:
salaries[0] = 50000;
salaries[1] = 75340;
salaries[2] = 110500;
salaries[3] = 98270;
salaries[4] = 39400;
Exemple plus visuel de création de tableau:
Pour en savoir plus sur les tableaux, consultez le guide .
Pour une classe générique, il est nécessaire de créer une classe wrapper . Par exemple:
Set<String>[] sets = new HashSet<>[10]
résultats dans: "Impossible de créer un tableau générique"
Utilisez à la place:
class SetOfS{public Set<String> set = new HashSet<>();}
SetOfS[] sets = new SetOfS[10];