TOC

Jagged Arrays In Java

Tableaux multidimensionnels en Java

1. Vue d'ensemble

Un tableau multidimensionnel en Java est un tableau comprenant des tableaux de différentes tailles. Il est également appelé «un tableau de tableaux» ou «tableau irrégulier» ou «tableau dentelé».

Dans ce rapide didacticiel, nous examinerons plus en détail la définition et l'utilisation de tableaux multidimensionnels.

2. Création d'un tableau multidimensionnel

Commençons par examiner les moyens de créer un tableau multidimensionnel:

2.1. La forme abrégée

Un moyen simple de définir un tableau multidimensionnel serait: 

int[][] multiDimensionalArr = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}};

Ici, nous avons déclaré et initialisémultiDimensionalArr en une seule étape.

2.2. Déclaration puis initialisation

Nous commençons par déclarer un tableau multi-dimensionnel de taille trois: 

int[][] multiDimensionalArr = new int[3][];

Ici,we’ve omitted to specify the second dimension since it will vary.

Ensuite, allons plus loin en déclarant et en initialisant les éléments respectifs dansmultiDimensionalArr: 

multiDimensionalArr[0] = new int[] {1, 2};
multiDimensionalArr[1] = new int[] {3, 4, 5};
multiDimensionalArr[2] = new int[] {6, 7, 8, 9};

On peut aussi simplement déclarer ses éléments sans les initialiser: 

multiDimensionalArr[0] = new int[2];
multiDimensionalArr[1] = new int[3];
multiDimensionalArr[2] = new int[4];

Celles-ci peuvent ensuite être initialisées ultérieurement, par exemple à l'aide d'entrées utilisateur.

Nous pouvons également utiliser la méthodejava.util.Arrays.fill pour initialiser les éléments du tableau: 

void initialize2DArray(int[][] multiDimensionalArray) {
    for (int[] array : multiDimensionalArray) {
        Arrays.fill(array, 7);
    }
}

Tous les éléments des tableaux sont initialisés avec la même valeur.

3. Représentation de la mémoire

À quoi ressemblera la représentation mémoire de nosmultiDimensionalArr?

Comme on le sait, un tableau en Java n’est rien d’autre qu'un objet dont les éléments pourraient être des primitives ou des références. Ainsi, un tableau à deux dimensions en Java peut être considéré comme un tableau de tableaux à une dimension.

NosmultiDimensionalArr en mémoire ressembleraient à:

image

Clairement,multiDimensionalArr[0] contient une référence à un tableau unidimensionnel de taille 2,multiDimensionalArr[1] contient une référence à un autre tableau unidimensionnel de taille 3 et ainsi de suite.

De cette façon, Java nous permet de définir et d’utiliser des tableaux multidimensionnels.

4. Itérer sur des éléments

Nous pouvons itérer un tableau multidimensionnel un peu comme n'importe quel autre tableau en Java.

Essayons d'itérer et d'initialiser les élémentsmultiDimensionalArr à l'aide des entrées utilisateur: 

void initializeElements(int[][] multiDimensionalArr) {
    Scanner sc = new Scanner(System.in);
    for (int outer = 0; outer < multiDimensionalArr.length; outer++) {
        for (int inner = 0; inner < multiDimensionalArr[outer].length; inner++) {
            multiDimensionalArr[outer][inner] = sc.nextInt();
        }
    }
}

Ici,multiDimensionalArr[outer].length est la longueur d'un tableau à un indexouter enmultiDimensionalArr.

It helps us to ensure that we are looking for elements only within a valid range of each sub-array, évitant ainsi unArrayIndexOutOfBoundException.

5. Éléments d'impression

Que faire si nous voulons imprimer les éléments de notre tableau multidimensionnel?

Une manière évidente serait d'utiliser la logique d'itération que nous avons déjà couverte. Cela implique une itération à travers chaque élément de notre tableau multidimensionnel, qui est lui-même un tableau, puis une itération sur ce tableau enfant - un élément à la fois.

Une autre option que nous avons est d'utiliser la méthode d'assistance dejava.util.Arrays.toString(): 

void printElements(int[][] multiDimensionalArr) {
    for (int index = 0; index < multiDimensionalArr.length; index++) {
        System.out.println(Arrays.toString(multiDimensionalArr[index]));
    }
}

Et nous finissons par avoir un code propre et simple. La sortie de la console générée ressemblerait à ceci: 

[1, 2] [3, 4, 5] [6, 7, 8, 9]

6. Longueur des éléments

Nous pouvons trouver la longueur des tableaux dans un tableau multidimensionnel en effectuant une itération sur le tableau principal: 

int[] findLengthOfElements(int[][] multiDimensionalArray) {
    int[] arrayOfLengths = new int[multiDimensionalArray.length];
    for (int i = 0; i < multiDimensionalArray.length; i++) {
        arrayOfLengths[i] = multiDimensionalArray[i].length;
    }
    return arrayOfLengths;
}

Nous pouvons également trouver la longueur des tableaux utilisant des flux Java: 

Integer[] findLengthOfArrays(int[][] multiDimensionalArray) {
    return Arrays.stream(multiDimensionalArray)
      .map(array -> array.length)
      .toArray(Integer[]::new);
}

7. Copier un tableau 2D

Nous pouvons copier un tableau 2D en utilisant la méthodeArrays.copyOf: 

int[][] copy2DArray(int[][] arrayOfArrays) {
    int[][] copied2DArray = new int[arrayOfArrays.length][];
    for (int i = 0; i < arrayOfArrays.length; i++) {
        int[] array = arrayOfArrays[i];
        copied2DArray[i] = Arrays.copyOf(array, array.length);
    }
    return copied2DArray;
}

Nous pouvons également y parvenir en utilisant des flux Java: 

Integer[][] copy2DArray(Integer[][] arrayOfArrays) {
    return Arrays.stream(arrayOfArrays)
      .map(array -> Arrays.copyOf(array, array.length))
      .toArray(Integer[][]::new);
}

8. Conclusion

Dans cet article, nous avons examiné la nature des tableaux multidimensionnels, leur apparence en mémoire et la manière dont nous pouvons les définir et les utiliser.

Comme toujours, le code source des exemples présentés se trouve àover on GitHub.

Related