Tableaux à deux dimensions

1. Introduction

Imaginez un tableau simple comme une longue boîte à pizza où toutes les parts sont alignées — délicieux, mais monotone.

Et maintenant, imaginons un planning de travail ou un échiquier. Là, tout est organisé en lignes et colonnes — c’est‑à‑dire en tableau. Voilà une tâche classique pour un tableau à deux dimensions.

Dans la vie réelle, les tableaux 2D se rencontrent partout :

• Des tableaux avec les salaires des employés (lignes — employés, colonnes — mois).
• L’image à l’écran (chaque « cellule » — la couleur d’un pixel, avec deux coordonnées : X et Y).
• Des calculs matriciels et le traitement de données.
• Un échiquier ou une grille de morpion.

Parfois, un tableau à deux dimensions est appelé une matrice (terme issu des mathématiques).

Il existe de très nombreux cas où, en tant que développeur, vous pourriez avoir besoin d’un tableau 2D. L’implémentation de pratiquement n’importe quel jeu de plateau — c’est un tableau 2D prêt à l’emploi : « Échecs », « Dames », « Morpion », « Bataille navale » :

Le plateau des « Échecs » ou de la « Bataille navale » s’adapte parfaitement aux tableaux 2D, où, comme coordonnées des cases, il suffit d’utiliser des nombres. Pas « pion e2 ⟶ e4 », mais « pion (4,1) ⟶ (4,3) ». Pour vous, en tant que programmeur, ce sera même plus simple.

2. Syntaxe de déclaration des tableaux à deux dimensions

Ça n’est intimidant que jusqu’à la première déclaration ! Décortiquons pas à pas.

Règle générale

tip[][] imyaMassiva;

Ici, deux paires de crochets vides [] — ce n’est pas une erreur du compilateur après une nuit caféinée, mais l’indication que le tableau est bidimensionnel.

Exemples

int[][] matrix;
double[][] gradesTable;
string[][] chessBoard;

Création du tableau

Définissons les dimensions : nombre de lignes et de colonnes.

matrix = new int[3][4]; // 3 lignes, 4 colonnes

C’est un tableau 3×4 : imaginez une feuille Excel avec 3 lignes et 4 colonnes.

On peut aussi déclarer la variable et créer le tableau 2D en une seule fois :

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

On peut l’initialiser directement avec des valeurs (à peu près comme pour un tableau à une dimension) :

int[][] example = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
// Tableau 3 lignes, 3 colonnes

Schéma visuel

┌─────┬─────┬─────┬─────┐
│  0  │  1  │  2  │  3  │  ← colonnes (Columns)
├─────┼─────┼─────┼─────┤
│ 0,0 │ 0,1 │ 0,2 │ 0,3 │  ← ligne 0 (Row 0)
├─────┼─────┼─────┼─────┤
│ 1,0 │ 1,1 │ 1,2 │ 1,3 │  ← ligne 1 (Row 1)
├─────┼─────┼─────┼─────┤
│ 2,0 │ 2,1 │ 2,2 │ 2,3 │  ← ligne 2 (Row 2)
└─────┴─────┴─────┴─────┘

Chaque élément est défini par une paire d’indices [ligne, colonne].

3. Indexation et accès aux éléments

Dans un tableau 2D, pour accéder à un élément, on indique deux indices :

• Le premier — le numéro de la ligne.
• Le second — le numéro de la colonne.

      // Deuxième ligne (indice 1), troisième colonne (indice 2)
      matrix[1][2] = 99;

Pour ceux qui ont l’habitude des échecs, rappelons que l’indexation commence à zéro. Autrement dit, le premier élément est [0][0].

Écriture et lecture

int[][] data = new int[5][2];
data[1][1] = 5;         // écriture
int value = data[1][1]; // lecture

Voici à quoi cela ressemblera en mémoire :

4. Remplir un tableau à deux dimensions

Écrivons un code qui remplit la matrice avec des nombres consécutifs de 1 à 12, pour bien comprendre comment cela fonctionne.

int[][] matrix = new int[3][4];
int value = 1;

for (int row = 0; row < 3; row++)
{
    for (int col = 0; col < 4; col++)
    {
        matrix[row][col] = value;
        value++;
    }
}

Illustration :

Après exécution :
┌────┬────┬────┬────┐
│ 1  │ 2  │ 3  │ 4  │
├────┼────┼────┼────┤
│ 5  │ 6  │ 7  │ 8  │
├────┼────┼────┼────┤
│ 9  │ 10 │ 11 │ 12 │
└────┴────┴────┴────┘

5. Structure des tableaux à deux dimensions

Vous allez maintenant découvrir comment les tableaux 2D sont réellement conçus. Prêts ?

Les tableaux 2D sont en réalité des tableaux de tableaux !

Autrement dit, dans le cas d’un tableau simple, « la variable‑tableau stocke une référence vers un conteneur qui stocke les éléments du tableau », tandis que pour les tableaux 2D, la situation est un peu plus explosive : la variable‑tableau‑2D stocke une référence vers un conteneur qui stocke des références vers des tableaux 1D. Mieux vaut le voir une fois que de l’expliquer cent fois :

À gauche, nous avons une « variable‑tableau‑2D » qui stocke une référence vers un « objet‑tableau 2D ». Au milieu, nous avons l’« objet tableau 2D », dans les cases duquel sont stockées des références vers des tableaux 1D — les lignes du tableau 2D. Et à droite, vous voyez quatre tableaux 1D — les lignes de notre tableau 2D.

Voilà comment les tableaux 2D sont réellement organisés. Cette approche offre au développeur Java plusieurs avantages :

Premièrement, puisque le « conteneur de conteneurs » stocke des références vers des « tableaux‑lignes », nous pouvons échanger des lignes très rapidement et très simplement. Pour accéder au « conteneur de conteneurs », il suffit d’indiquer un seul indice au lieu de deux. Exemple :

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

Avec ce code, on peut échanger des lignes :

// Matrice importante avec des données
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

Si vous accédez à une case d’un tableau 2D, mais qu’après le nom du tableau vous ne fournissez qu’un seul indice, vous accédez ainsi au conteneur de conteneurs, dans les cases duquel sont stockées des références vers des tableaux 1D ordinaires.

6. Affichage d’un tableau à deux dimensions

Pour afficher un tableau 2D, on utilise généralement une double boucle — c’est un peu comme dessiner un labyrinthe dans la console. Exemple :

for (int row = 0; row < matrix.length; row++) 
{
    for (int col = 0; col < matrix[row].length; col++) 
    {
        System.out.print(matrix[row][col] + "\t"); 
    }
    System.out.println(); // saut de ligne
}

Exemple de sortie :

1	2	3	4	
5	6	7	8	
9	10	11	12	

Au passage, vous venez d’apprendre à « dessiner » de jolis tableaux avec quelques lignes de code !