Tableau d'objets dans Java

Qu'est-ce qu'un tableau d'objets dans Java?

A Java tableau d'objets stocke plusieurs instances d'objets de la même classe dans un seul conteneur de taille fixe. Contrairement à un tableau primitif qui stocke des valeurs telles que int, double, boolean directement dans chaque emplacement, un tableau d'objets est stocké référencesChaque emplacement pointe vers l'emplacement mémoire d'un objet, et l'objet lui-même réside sur la mémoire. Java tas.

Cette disposition correspond à la façon dont n'importe quel objet variable in Java Cela fonctionne. Le tableau regroupe simplement plusieurs références d'objets afin que vous puissiez y accéder par leur index. C'est le choix idéal lorsque le nombre d'objets est connu à l'avance et reste constant pendant toute la durée de vie du programme.

Syntaxe

ClassName[] obj = new ClassName[array_length];

Le côté droit réserve de l'espace pour array_length références, toutes initialisées à null. Aucun objet de ClassName Il n'existe pour l'instant que le conteneur qui peut contenir des références à de tels objets.

Comment créer un tableau d'objets dans Java

La création d'un tableau d'objets fonctionnel nécessite toujours deux étapes d'allocation. La première alloue le conteneur de référence, et la seconde alloue chaque objet vers lequel ce conteneur pointera.ping la deuxième étape est la source la plus courante de NullPointerException débutant Java code.

Étape 1) Ouvrez votre éditeur de code et copiez le code suivant :

class ObjectArray {
    public static void main(String args[]) {
        Account obj[] = new Account[2];
        // obj[0] = new Account();
        // obj[1] = new Account();
        obj[0].setData(1, 2);
        obj[1].setData(3, 4);
        System.out.println("For Array Element 0");
        obj[0].showData();
        System.out.println("For Array Element 1");
        obj[1].showData();
    }
}

class Account {
    int a;
    int b;

    public void setData(int c, int d) {
        a = c;
        b = d;
    }

    public void showData() {
        System.out.println("Value of a = " + a);
        System.out.println("Value of b = " + b);
    }
}

Étape 2) Enregistrez le fichier sous ObjectArray.java, puis compilez-le et exécutez-le.

Étape 3) Notez l'erreur. Essayez de la corriger avant de passer à l'étape 4.

Étape 4) Inspecter la ligne Account obj[] = new Account[2];Il alloue un tableau de deux variables de référence de type Accountmais il n'en alloue aucun Account objets. Les deux emplacements peuvent contenir nullet en appelant obj[0].setData(...) sur un null La référence génère une erreur NullPointerException à l'exécution.

Étape 5) Décommentez les lignes 4 et 5. Ces deux lignes créent de véritables Account objets et les assigner à obj[0] et obj[1]Le tableau contient désormais de véritables références et le code s'exécute sans problème.

Sortie :

For Array Element 0
Value of a = 1
Value of b = 2
For Array Element 1
Value of a = 3
Value of b = 4

Comment initialiser un tableau d'objets dans Java

Outre l'initialisation par setter présentée ci-dessus, un tableau d'objets peut être initialisé de trois manières plus élégantes. Chaque style privilégie la clarté au détriment de la verbosité ; choisissez donc celui qui convient le mieux à votre situation.

1. Initialisation de la boucle — On alloue d'abord le tableau, puis on parcourt chaque index et on assigne un nouvel objet. C'est le modèle standard pour les grands tableaux ou lorsque le nombre d'objets est dynamique.
2. Initialisation du constructeur — Transmettre directement les valeurs au constructeur lors de la création, évitant ainsi un appel de setter séparé.
3. Initialisation littérale de tableau — déclarer et remplir en une seule instruction avec un en ligne { ... } Initialiseur, idéal pour les petits ensembles fixes.

class Account {
    int a, b;

    public Account(int a, int b) {   // constructor
        this.a = a;
        this.b = b;
    }
}

public class InitDemo {
    public static void main(String[] args) {

        // 1) Loop initialisation
        Account[] loopArr = new Account[3];
        for (int i = 0; i < loopArr.length; i++) {
            loopArr[i] = new Account(i, i * 10);
        }

        // 2) Constructor initialisation, one slot at a time
        Account[] ctorArr = new Account[2];
        ctorArr[0] = new Account(1, 2);
        ctorArr[1] = new Account(3, 4);

        // 3) Array literal initialisation
        Account[] litArr = {
            new Account(5, 6),
            new Account(7, 8),
            new Account(9, 10)
        };

        System.out.println("loop size   = " + loopArr.length);
        System.out.println("ctor size   = " + ctorArr.length);
        System.out.println("literal size= " + litArr.length);
    }
}

L'initialisation en boucle est le comportement par défaut le plus sûr car elle garantit qu'aucun emplacement n'est laissé vacant. nullL'initialisation par constructeur explicite l'intention lorsque chaque objet requiert des arguments différents, et les littéraux de tableau permettent de conserver un code de démonstration concis. Évitez de mélanger les styles au sein d'un même tableau, sauf raison valable : la cohérence facilite la détection des bogues.

Itération et accès aux éléments dans un Java Tableau d'objets

Une fois le tableau d'objets rempli, trois modèles couvrent la quasi-totalité des besoins d'accès. Choisissez le style de boucle qui correspond au niveau de contrôle requis sur l'index.

Classique for boucle donne accès à l'index, ce qui est utile pour remplacer des éléments, comparer des voisins ou parcourir une sous-plage.

for (int i = 0; i < obj.length; i++) {
    System.out.println("Element " + i);
    obj[i].showData();
}

Renforcer la compréhension for boucle (La boucle « for-each ») masque l'index et la lecture est plus naturelle lorsque l'index n'est pas nécessaire :

for (Account acc : obj) {
    acc.showData();
}

Flux (Java 8 et suivants) convertir le tableau en pipeline, ce qui est pratique pour le filtrage, mapperping, ou en effectuant une agrégation sans écrire de boucle :

import java.util.Arrays;

Arrays.stream(obj)
      .filter(acc -> acc.a > 0)
      .forEach(Account::showData);

Pour lire ou mettre à jour un seul élément, utilisez l'accès direct à l'index, par exemple. obj[1].setData(10, 20)Vérifiez toujours d'abord la longueur avec obj.length pour éviter ArrayIndexOutOfBoundsException.Quand n'importe quel emplacement pourrait être null, protégez l'accès avec une vérification de valeur nulle ou une Optional pour que le programme continue de fonctionner au lieu de planter.

Tableau d'objets vs ArrayList d'objets dans Java

Un simple tableau d'objets est rapide et prévisible, mais sa taille fixe devient une limitation dès que le nombre d'objets change lors de l'exécution. Java's Cadre des collections offre aux ArrayList comme alternative dynamique. Le tableau ci-dessous indique quand chaque option est appropriée.

Utilisez un tableau lorsque l'empreinte mémoire réduite et l'indexation prévisible sont importantes, par exemple dans les dispositions matricielles ou les chemins d'accès critiques en termes de performances. ArrayList dans la plupart des applications courantes, car la possibilité d'ajouter et de supprimer des éléments sans réallocation compense largement la faible surcharge par élément.

FAQ