Tableaux multidimensionnels

• Tableaux multidimensionnels, syntaxe générale
• Tableaux bidimensionnels
• Déclaration, création et initialisation de tableaux bidimensionnels
• Affichage d'un tableau bidimensionnel à l'écran
• Sortie rapide d'un tableau bidimensionnel
• « Longueurs » d'un tableau bidimensionnel
• Exemple d'utilisation d'un tableau à deux dimensions : damier
• Exemple d'utilisation d'un tableau à deux dimensions : multiplication matricielle
• Tableaux bidimensionnels non rectangulaires
• Tableaux tridimensionnels
• Les tableaux multidimensionnels dans le travail réel d'un programmeur Java
• Problèmes intéressants sur les tableaux bidimensionnels et tridimensionnels

Qu'est-ce qu'un tableau Java unidimensionnel ?

Un tableau est un ensemble ordonné d’éléments du même type, primitif ou référence. Des informations générales sur les tableaux (principalement unidimensionnels) peuvent être trouvées dans l'article « Arrays in Java » et dans le cours JavaRush . Dans cet article, nous parlerons des tableaux dont les éléments sont d'autres tableaux. De tels tableaux sont appelés multidimensionnels. Un tableau dont les éléments sont d'autres tableaux, c'est-à-dire un tableau de tableaux, est appelé bidimensionnel. Tous les langages n'ont pas de tableaux multidimensionnels structurés de cette façon, mais en Java c'est le cas.

Tableaux multidimensionnels Java, syntaxe générale

En général, les tableaux multidimensionnels en Java ressemblent à ceci :

Data_type[dimension1][dimension2][]..[dimensionN] array_name = new data_type[size1][size2]….[sizeN];

Où Data_typeest le type des éléments du tableau. Peut être primitif ou référence (classe). Le nombre de paires de crochets avec dimensionintérieur est la dimension du tableau (dans notre cas - N). array_name— nom du tableau size1...sizN— nombre d'éléments dans chaque dimension du tableau. Déclarer des tableaux multidimensionnels :

int[][] twoDimArray; //two-dimensional array
String[][][] threeDimArray; //three-dimensional array
double[][][][][] fiveDimArray; // five-dimensional array

Peut-être que tout cela semble très abstrait, passons maintenant aux manifestations concrètes des tableaux multidimensionnels - bidimensionnels et tridimensionnels. Le fait est que les développeurs Java utilisent parfois des tableaux à deux dimensions, beaucoup moins souvent - les tableaux à trois dimensions, et les tableaux encore plus grands sont extrêmement rares. Très probablement, vous ne les rencontrerez pas.

Qu'est-ce qu'un tableau Java bidimensionnel ?

Un tableau bidimensionnel en Java est un tableau de tableaux, c'est-à-dire que chaque cellule contient une référence à un tableau. Mais il est beaucoup plus simple de le présenter sous la forme d’un tableau comportant un nombre de lignes (première dimension) et un nombre de colonnes (deuxième dimension) donnés. Un tableau à deux dimensions dans lequel toutes les lignes comportent un nombre égal d’éléments est appelé rectangulaire.

Déclaration, création et initialisation de tableaux bidimensionnels

La procédure de déclaration et de création d'un tableau à deux dimensions est presque la même que dans le cas d'un tableau à une dimension :

int[][] twoDimArray = new int[3][4];

Ce tableau comporte 3 lignes et 4 colonnes. La taille d'un tableau bidimensionnel rectangulaire (ils peuvent ne pas être rectangulaires, plus d'informations ci-dessous), c'est-à-dire que le nombre total d'éléments peut être déterminé en multipliant le nombre de lignes par le nombre de colonnes. Il est maintenant initialisé (rempli) avec les valeurs par défaut. Autrement dit, des zéros. Remplissons-le avec les valeurs dont nous avons besoin.

twoDimArray[0][0] = 5;//write the value 5 into the cell at the intersection of the zero row and zero column
twoDimArray[0][1] = 7; //write the value 7 into the cell at the intersection of the zero row and the first column
twoDimArray[0][2]  = 3;
twoDimArray[0][3] = 17;
twoDimArray[1][0] = 7;
twoDimArray[1][1] = 0;
twoDimArray[1][2] = 1;
twoDimArray[1][3] = 12;
twoDimArray[2][0] = 8;
twoDimArray[2][1] = 1;
twoDimArray[2][2] = 2;
twoDimArray[2][3] = 3;

Comme pour les tableaux unidimensionnels, vous pouvez effectuer la procédure d'initialisation plus rapidement :

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};

Dans les deux cas, nous obtiendrons un tableau bidimensionnel à trois lignes et quatre colonnes, rempli d’entiers.

Affichage d'un tableau bidimensionnel à l'écran

La manière la plus logique d'effectuer cette opération est d'afficher d'abord la ligne zéro élément par élément, puis la seconde, et ainsi de suite. La manière la plus courante de générer un tableau à deux dimensions en Java consiste à utiliser deux boucles imbriquées.

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};//declared an array and filled it with elements
for (int i = 0; i < 3; i++) {  //go through the lines
            for (int j = 0; j < 4; j++) {//go through the columns
                System.out.print(" " + twoDimArray[i][j] + " "); //output element
            }
            System.out.println();// line wrap for the visual preservation of the tabular form
        }

Sortie rapide d'un tableau bidimensionnel

Le moyen le plus court d'afficher une liste d'éléments d'un tableau bidimensionnel à l'écran est d'utiliser la méthode deepToStringde classe Arrays. Exemple:

int[][] myArray = {{18,28,18},{28,45,90},{45,3,14}};
System.out.printLn(Arrays.deepToString(myArray));

Le résultat du programme est la sortie suivante : [[18, 28, 18], [28, 45, 90], [45, 3, 14]]

« Longueurs » d'un tableau bidimensionnel

Pour obtenir la longueur d'un tableau unidimensionnel (c'est-à-dire le nombre d'éléments qu'il contient), vous pouvez utiliser la variable length. Autrement dit, si nous définissons un tableau int a[] = {1,2,3}, alors l'opération a.lengthrenvoie 3. Mais que se passe-t-il si nous appliquons la même procédure à notre tableau à deux dimensions ?

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};
System.out.println(twoDimArray.length);

Sortie : 3 Cette opération génère donc le nombre de lignes dans le tableau. Comment obtenir le nombre de colonnes ? Si nous avons affaire à des tableaux rectangulaires à deux dimensions (c'est-à-dire ceux dans lesquels toutes les lignes ont la même longueur), nous pouvons alors appliquer l'opération twoDimArray[0].lengthou à la place de l'élément zéro (essentiellement la ligne zéro) - tout autre élément existant. Nous pouvons le faire car en Java, un tableau à deux dimensions est un tableau de tableaux et l'élément zéro twoDimArray[0]est un tableau de longueur 4. Vous pouvez le vérifier vous-même.

Exemple d'utilisation d'un tableau à deux dimensions : damier

Les tableaux bidimensionnels peuvent être utilisés pour créer n'importe quel champ bidimensionnel fini, par exemple dans les jeux, et en particulier aux échecs. Il est facile de considérer un échiquier comme un tableau à deux dimensions. Vous pouvez y "attacher" des graphiques, mais pour l'instant, définissons un échiquier à l'aide de symboles et l'envoyons à la console. La case inférieure gauche de l'échiquier est peinte en noir, la suivante est blanche, tout comme celle du dessus. Ainsi, la couleur change à chaque fois que vous vous déplacez vers une cellule adjacente au côté. Pour définir la coloration des échecs non pas manuellement, mais à l'aide d'un algorithme, vous pouvez utiliser un contrôle de parité : si la somme des index de ligne et de colonne est paire ou nulle, alors la cellule sera blanche, sinon elle sera noire. Pour cette vérification, nous utilisons l'opérateur de reste % dans l'algorithme. Puisque nous ne travaillons pas avec des graphiques, mais avec des symboles, nous désignerons la cellule blanche par la lettre W(blanche) et la cellule noire par la lettre B(noire).

//set the chessboard as a two-dimensional array
String [][] chessBoard = new String[8][8];
        for (int i = 0; i< chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W";
                else chessBoard[i][j] = "B";
            }
        }

La sortie du programme est la suivante : WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWWBWBWBWBBW BWBWBWWBWBWBWBBWBWBWBW W Tout est comme sur un vrai échiquier, vous pouvez le vérifier. Écrivons maintenant une méthode pour numéroter correctement les cellules non pas en langage tableau, mais en langage « d'échecs ». La cellule en bas à gauche du tableau s'appelle A1, alors que dans notre tableau, elle s'appelle chessBoard[7][0]. Associons chaque paire d'indices d'un tableau bidimensionnel à leur équivalent « d'échecs ». Pour ce faire, on utilise deux lignes - " abcdefgh" et " 87654321" (dans l'ordre inverse - pour plus de simplicité, afin que le damier 8 corresponde à la colonne zéro).

public static String chessBoardCoord(int a, int b) {
            String letters = "abcdefgh";
            String numbers = "87654321";
            if ((a > 7)|| (b>7)) return null; //if the number is outside the board, return the default value - null
            else return (Character.toString(letters.charAt(a)) + numbers.charAt(b)); /*charAt - a method with which we extract from the string the element under the passed number, here - under the numbers a and b. Character.toString - a method that converts the received character into a string */
        }

Affichons maintenant dans chaque cellule non seulement sa couleur, mais aussi son numéro, en utilisant la méthodechessBoardCoord

String [][] chessBoard = new String[8][8];
        for (int i = 0; i < chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W" + chessBoardCoord(j,i);
                else chessBoard[i][j] = "B"+ chessBoardCoord(j,i);
            }
        }

            for (int i = 0; i < chessBoard.length; i++) {
                for (int j = 0; j < chessBoard[0].length; j++) {
                    System.out.print(" " + chessBoard[i][j] + " ");
                }
                System.out.println();
            }

Sortie du programme : Wa8 Bb8 Wc8 Bd8 We8 Bf8 Wg8 Bh8 Ba7 Wb7 Bc7 Wd7 Be7 Wf7 Bg7 Wh7 Wa6 Bb6 Wc6 Bd6 We6 Bf6 Wg6 Bh6 Ba5 Wb5 Bc5 Wd5 Be5 Wf5 Bg5 Wh5 Wa4 Bb4 Wc4 Bd4 We4 Bf4 Wg4 Bh4 Ba3 Wb3 Bc3 Wd 3 Be3 Wf3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 Où We2signifie le carré blanc numéroté e2.

Exemple d'utilisation d'un tableau à deux dimensions : multiplication matricielle

Attention!Cet exemple nécessite une connaissance de base des matrices. Ici, on en dira très peu à leur sujet, et ces informations sont destinées à ceux qui ont étudié, mais ont quelque peu oublié, l'arithmétique matricielle. Cependant, ces connaissances peuvent être glanées à partir de sources ouvertes, notamment à partir d' un article sur Wikipédia . C'est un bon exemple d'utilisation de tableaux bidimensionnels, mais nous pouvons continuer sans cela. Donc, si cela vous semble maintenant incompréhensible d'un point de vue mathématique, et que vous n'avez pas vraiment envie de vous y plonger, n'hésitez pas à sauter l'exemple. Si vous avez étudié l'algèbre linéaire de base, vous avez peut-être découvert les tableaux rectangulaires en tant que matrices rectangulaires. Où a11, a12... aNN sont des nombres. Sur la figure, la matrice n'est même pas rectangulaire, mais carrée (le nombre de lignes est égal au nombre de colonnes, mais ce n'est pas toujours le cas). Dans la vraie vie, de telles matrices sont rarement rencontrées, mais en programmation et en informatique, elles sont très courantes. Ils sont notamment utilisés dans l’infographie et les moteurs de jeux. Par exemple, la rotation d'un objet sur l'écran selon n'importe quel angle peut être programmée à l'aide d'une matrice de rotation. Dans un espace bidimensionnel, la matrice de rotation ressemble à ceci : Où thêta est l'angle selon lequel l'objet doit pivoter. Des matrices de dimensions égales peuvent être ajoutées les unes aux autres, et l'addition se fait élément par élément (nous ajoutons des éléments avec les mêmes indices). Mais l’opération de multiplication matricielle est moins familière. Ainsi, les matrices peuvent être multipliées et une matrice résultante ne peut être obtenue que si le nombre de colonnes de la première matrice coïncide avec le nombre de lignes de la seconde. La matrice résultat aura le même nombre de lignes que la première et le même nombre de colonnes que la seconde. La multiplication s'effectue comme suit. Ayons une matrice a[l][m]et b[m][n]. Grâce à leur multiplication, nous devrions obtenir une matrice c[l][n]. Pour obtenir un élément d' c[0][0]une matrice produit, il faut a[0][0]multiplier l'élément zéro de la ligne zéro de la première matrice par l'élément zéro de la deuxième matrice, puis multiplier le premier élément de la première ligne de la première matrice par le premier élément de la première colonne de la deuxième matrice, et ainsi de suite, après quoi tous les produits résultants sont ajoutés.

a[0][0]*b[0][0] + a[0][1]*b[1][0] + … + a[0][m-1]*b[m-1][0]

Pour obtenir le deuxième élément de la première ligne de la matrice résultat, on effectue la même procédure avec la deuxième ligne

a[1][0]*b[0][0] + a[1][1]*b[0][1] + … + a[0][m-1]*b[m-1][0]

Et ainsi de suite jusqu'à la fin de la ligne. Ensuite, nous passons à la ligne suivante et répétons la procédure jusqu'à ce que nous manquions de lignes. Autrement dit, nous multiplions les lignes de la première matrice par les colonnes de la deuxième matrice. Vous trouverez ci-dessous le code de multiplication matricielle. Vous pouvez le compléter par un contrôle du respect de la condition susvisée sur le nombre de lignes et de colonnes.

//declaring two matrices
int [][] twoDimArray1 = {{1,0,0,0},{0,1,0,0},{0,0,0,0}};
int[][] twoDimArray2 = {{1,2,3},{1,1,1},{0,0,0},{2,1,0}};

//matrix multiplication process
int[][]twoDimArray3 = new int [twoDimArray1.length][twoDimArray2[0].length];
        for (int i=0; i<twoDimArray3[0].length; i++)
            for (int j=0; j<twoDimArray3.length; j++)
                for (int k=0; k<twoDimArray1[0].length; k++)
                              twoDimArray3[i][j] = twoDimArray3[i][j] + twoDimArray1[i][k] * twoDimArray2[k][j];

//output on display
        for (int i = 0; i < twoDimArray3.length; i++) {
            for (int j = 0; j < twoDimArray3[0].length; j++) {
                System.out.print(" " + twoDimArray3[i][j] + " ");
            }
            System.out.println();
        }

Le programme génère le résultat suivant : 1 2 3 1 1 1 0 0 0

Tableaux bidimensionnels non rectangulaires

Étant donné que les tableaux bidimensionnels sont des tableaux de tableaux en Java, chacun des tableaux internes peut être de longueurs différentes. Lors de la création d’un tableau, on ne peut préciser que le nombre de lignes et non le nombre de colonnes (c’est-à-dire en fait la longueur de ces mêmes lignes). Regardons un exemple.

//declaring and creating an array, specifying only the number of rows
int [][] twoDimArray = new int[5][];

//initialize the array, filling it with arrays of different lengths
        twoDimArray[0] = new int[]{1, 2, 3, 4, 5};
        twoDimArray[1] = new int[]{1,2,3,4};
        twoDimArray[2] = new int[]{1,2,3};
        twoDimArray[3] = new int[]{1,2};
        twoDimArray[4] = new int[]{1};
//display the resulting non-rectangular two-dimensional array on the screen
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(" " + twoDimArray[i][j] + " ");
            }
            System.out.println();
        }

Résultat du programme : 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 Ainsi, la zéroième ligne de notre tableau contient le tableau {1,2,3,4,5}et la quatrième ligne contient le tableau {1}.

Tableaux tridimensionnels en Java

Suivant le bon sens et la logique du langage Java, un tableau tridimensionnel peut être appelé un « tableau de tableaux de tableaux » ou « un tableau dont chaque élément est un tableau bidimensionnel ». De plus, ces tableaux bidimensionnels peuvent être différents. Exemple:

// create a three-dimensional array consisting of two two-dimensional arrays
int[][][] threeDimArr = new int[2][][];
//create the first 2D array of a 5x2 3D array
        threeDimArr[0] = new int[5][2];
//create a second 2D array of a 1x1 3D array
        threeDimArr[1] = new int[1][1];

Mais le plus souvent, dans la pratique, il existe des tableaux tridimensionnels dans lesquels les trois quantités sont définies en même temps, un analogue des tableaux bidimensionnels rectangulaires. Comme nous l'avons déjà mentionné, les tableaux tridimensionnels ou plus sont très rarement utilisés. Cependant, vous pouvez programmer quelque chose d’intéressant avec un tableau 3D. Par exemple, un parking à plusieurs étages. Chaque étage peut être considéré comme un ensemble bidimensionnel, et une place de parking peut être considérée comme un élément spécifique d’un ensemble tridimensionnel. Un élément d'un tel tableau peut être représenté par un type booleanavec la valeur false si l'espace est libre et true si l'espace est occupé.

//set a boolean three-dimensional array. This car park has 3 floors, each of which can accommodate 2x5 = 10 cars. By default, all cells are empty (false)
boolean[][][] parkingLot = new boolean[3][2][5];
//two cars arrived and parked on the ground floor in cell [1][0] and [1][3]
        parkingLot[0][1][0] = true;
        parkingLot[0][1][3] = true;

//Output the array to the console
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + parkingLot[i][j][k] + "\t");

                }
                System.out.println();
            }
        }

Problèmes intéressants sur les tableaux bidimensionnels et tridimensionnels

Vous en savez suffisamment sur les tableaux multidimensionnels en Java et, si vous vous sentez en confiance, vous pouvez essayer de résoudre certains des problèmes ci-dessous. Ce n’est pas facile, mais intéressant. Morpion. Créez un terrain 3x3, créez deux joueurs qui se relaient. Initialement, le terrain est vide, et dans chacun des champs vides, le premier joueur peut mettre une croix et le second un zéro. Le gagnant est celui qui rassemble en premier trois croix ou trois zéros disposés sur une ligne, une colonne ou en diagonale. La fourmi de Langton . Il existe un certain champ divisé en cellules (un tableau bidimensionnel), peint en noir ou en blanc (peut être défini par une fonction aléatoire). Une « fourmi » se matérialise au hasard dans l’une des cellules et, à chaque pas, elle peut se déplacer dans l’une des quatre directions vers la cellule adjacente, horizontalement ou verticalement. Règles de déplacement des fourmis :

• Sur une case noire, la fourmi doit tourner de 90° vers la gauche, changer la couleur de sa cellule en blanc, puis avancer jusqu'à la case suivante.
• Sur un carré blanc, la fourmi tourne de 90° vers la droite et change la couleur de sa cellule en noir, puis avance vers le carré suivant.

Écrivez une méthode qui calcule l'itération au numéro d'étape nen fonction de la position initiale de la fourmi. Le champ peut être rempli aléatoirement avec des zéros et des uns (ou désigné par les lettres Wet B, comme nous l'avons fait dans l'exemple de l'échiquier). Nous avons également besoin de deux paramètres supplémentaires - la position horizontale et verticale de la fourmi, ainsi que sa direction à ce stade (nord, sud, ouest, est), alors que par défaut la fourmi regarde vers le nord. Vous pouvez essayer de modéliser un Rubik's cube à l'aide de tableaux tridimensionnels. Un Rubik's cube standard a 6 faces, et chacune d'elles est un tableau tridimensionnel de carrés colorés Color[][][] rubik = new Color[6][3][3]. Cependant, la mise en œuvre d’un Rubik’s cube n’est pas une tâche anodine.

Documents utiles sur les tableaux

De nombreux articles sur JavaRush sont consacrés aux tableaux (principalement unidimensionnels, car ils sont beaucoup plus souvent utilisés en pratique). Faites attention à eux.

1. Tableaux en Java - à propos des tableaux pour débutants avec exemples
2. Something About Arrays - Bon article détaillé sur les tableaux
3. La classe Arrays et son utilisation - l'article décrit quelques méthodes de la classeArray
4. Arrays est la première conférence JavaRush dédiée aux tableaux.
5. Renvoie un tableau de longueur nulle, pas nul - Joshua Bloch, auteur d'Effective Programming, explique comment mieux renvoyer des tableaux vides