Tableaux multidimensionnels en Java

1. Vue d'ensemble

Un tableau multidimensionnel en Java est un tableau comprenant des tableaux de différentes tailles en tant qu'éléments. 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 regarder comment nous pouvons 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 multidimensionnel de taille trois:

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

Ici, nous avons omis de spécifier la deuxième dimension car elle variera .

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

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

Ceux-ci peuvent ensuite être initialisés, par exemple en utilisant des entrées utilisateur.

Nous pouvons également utiliser la méthode java.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 notre multiDimensionalArr ?

Comme nous le savons, un tableau en Java n'est rien d'autre qu'un objet dont les éléments peuvent être des primitives ou des références. Ainsi, un tableau bidimensionnel en Java peut être considéré comme un tableau de tableaux unidimensionnels.

Notre multiDimensionalArr en mémoire ressemblerait à:

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ération sur les éléments

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

Essayons d'itérer et d'initialiser les éléments multiDimensionalArr à 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 [external] .length est la longueur d'un tableau à un index externe dans multiDimensionalArr .

Cela nous aide à nous assurer que nous recherchons des éléments uniquement dans une plage valide de chaque sous-tableau , évitant ainsi une ArrayIndexOutOfBoundException .

5. Éléments d'impression

Et 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 de parcourir chaque élément de notre tableau multidimensionnel, qui est lui-même un tableau, puis d'itérer sur ce tableau enfant - un élément à la fois.

Une autre option que nous avons est d'utiliser la méthode d'assistance java.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 console générée ressemblerait à:

[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 itérant 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 en utilisant les flux Java:

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

7. Copie d'une matrice 2D

Nous pouvons copier un tableau 2-D en utilisant la méthode Arrays.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é ce que sont les 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 à l'adresse over sur GitHub.