Initialiser un tableau dans le constructeur en Java

Lors de la création d’un objet Java, initialisez un tableau de l’instance dans le constructeur si son contenu initial dépend des arguments du constructeur ou d’autres opérations de préparation. Si les valeurs par défaut de Java conviennent, il suffit d’allouer le tableau. Un tableau déclaré comme variable locale dans le constructeur n’est disponible que pendant l’exécution de celui-ci ; il ne fait pas partie de l’état de l’objet.

Initialiser un champ tableau dans un constructeur Java

Déclarez le tableau comme champ d’instance, puis affectez-lui une référence de tableau dans le constructeur. Celui-ci s’exécute à chaque création d’un objet : il peut donc initialiser le champ à partir des données de cet objet ou y placer des valeurs calculées pour lui.

Le champ tableau et le tableau auquel il fait référence sont deux éléments distincts : le champ contient une référence, tandis que le tableau contient les éléments. La création du tableau avec new int[size] alloue ses éléments et attribue à chacun sa valeur par défaut. Affecter un tableau local à un champ, par exemple avec this.values = values, stocke cette référence ; faites une copie si l’objet doit posséder un contenu indépendant.

Utiliser les valeurs par défaut de Java pour un tableau

Java attribue des valeurs par défaut aux champs d’instance avant l’exécution du corps du constructeur. Lorsque le constructeur crée un tableau, Java initialise aussi ses éléments : les éléments de type primitif numérique valent zéro (0 pour les types entiers et 0.0 pour float et double), ceux de type char valent \\u0000, ceux de type boolean valent false, et les éléments de type référence, comme String, valent null.

Par exemple, private int[] values = new int[3]; crée un champ d’instance contenant trois éléments initialisés à zéro. Vous pouvez aussi déclarer private int[] values; et affecter values = new int[3]; dans le constructeur : les éléments vaudront toujours zéro. N’ajoutez pas de boucle pour attribuer ces mêmes valeurs, sauf si cette affectation répond à une exigence distincte.

Affecter des valeurs précises dans le constructeur

Pour un contenu fixe, utilisez un initialiseur de tableau. Si chaque objet doit recevoir un contenu fourni par l’appelant, acceptez les valeurs comme paramètres du constructeur. Par exemple, this.values = new int[] {1, 2, 3}; donne ces trois valeurs au champ. Un constructeur qui reçoit un tableau en paramètre peut l’affecter directement ou en faire une copie, selon que les modifications ultérieures du tableau de l’appelant doivent aussi affecter l’objet.

L’exemple ci-dessous regroupe plusieurs approches dans une même classe. Il crée un champ rempli avec les valeurs par défaut, copie les valeurs reçues, remplit un autre champ avec une valeur unique, calcule des valeurs à partir des indices et utilise un tableau local pendant la construction. Le programme affiche chaque tableau afin que vous puissiez adapter les parties qui conviennent à votre classe.

import java.util.Arrays;

public class ArraySetup {
    private final int[] defaults = new int[3];
    private final int[] supplied;
    private final int[] repeated = new int[3];
    private final int[] calculated = new int[3];

    public ArraySetup(int[] source) {
        supplied = Arrays.copyOf(source, source.length);
        Arrays.fill(repeated, 7);
        Arrays.setAll(calculated, index -> (index + 1) * 2);

        int[] local = {4, 5};
        System.out.println("Local: " + Arrays.toString(local));
    }

    public static void main(String[] args) {
        int[] input = {3, 6, 9};
        ArraySetup item = new ArraySetup(input);
        System.out.println("Defaults: " + Arrays.toString(item.defaults));
        System.out.println("Supplied: " + Arrays.toString(item.supplied));
        System.out.println("Repeated: " + Arrays.toString(item.repeated));
        System.out.println("Calculated: " + Arrays.toString(item.calculated));
    }
}

Créer un tableau local dans le constructeur

Une déclaration telle que int[] local = {4, 5}; dans un constructeur crée une variable locale. Le code de ce constructeur peut l’utiliser, mais les autres méthodes ne peuvent plus y accéder une fois le constructeur terminé. Si le tableau doit faire partie de l’état de l’objet créé, affectez-le plutôt à un champ d’instance, par exemple avec this.values = new int[] {4, 5};.

Un tableau local peut tout de même servir de donnée temporaire pour construire un champ ou effectuer un calcul nécessaire uniquement pendant la préparation de l’objet. Gardez la distinction à l’esprit : l’objet tableau peut rester accessible si un champ ou un autre objet conserve sa référence, mais une variable locale au constructeur ne suffit pas à le préserver.

Utiliser Arrays.copyOf(), Arrays.fill() ou Arrays.setAll()

Choisissez la méthode en fonction de la manière dont le contenu est déterminé. Arrays.copyOf(source, source.length) crée un tableau distinct contenant les éléments du tableau source. Si la longueur demandée est plus courte ou plus longue, la méthode copie les éléments qui tiennent ; dans une copie plus longue, les éléments supplémentaires reçoivent leur valeur par défaut. Pour un tableau d’objets, la copie est superficielle : les références sont copiées, mais les objets référencés ne sont pas dupliqués.

Utilisez Arrays.fill(array, value) si tous les éléments doivent recevoir la même valeur. Utilisez Arrays.setAll(array, index -> expression) si chaque valeur dépend de son indice. Dans l’exemple, l’appel à fill attribue 7 à tous les éléments, tandis que la fonction fondée sur l’indice attribue des nombres pairs successifs. Ces méthodes modifient le tableau qui leur est transmis ; elles n’en créent pas un nouveau.

Choisir une méthode d’initialisation

Utilisez un tableau de taille définie et les valeurs par défaut lorsque celles-ci correspondent à l’état initial souhaité. Pour un petit ensemble fixe, utilisez un initialiseur de tableau ; si l’appelant choisit le contenu, transmettez-le au constructeur. Copiez le tableau reçu si l’objet doit disposer de sa propre structure de tableau ; utilisez Arrays.fill() pour répéter une valeur et Arrays.setAll() pour calculer des valeurs à partir des indices. Déclarez le tableau comme champ d’instance s’il doit rester accessible dans l’état de l’objet après sa construction.