1. Les tableaux irréguliers se distinguent des tableaux 2D
Nous arrivons à un sujet que beaucoup appellent « tableaux irréguliers » — en anglais jagged arrays. Contrairement aux tableaux à deux dimensions, les tableaux irréguliers permettent d’avoir des lignes de longueurs différentes. C’est comme un complexe d’immeubles où chaque bâtiment a son propre nombre d’appartements: dans un bâtiment il y en a 5, dans un autre 20, et dans un troisième — un seul.
Un tableau irrégulier est un tableau dont chaque élément est lui-même un tableau, et ces tableaux imbriqués (on les appelle aussi « sous-tableaux ») peuvent avoir des longueurs différentes.
La différence principale:
- Dans un tableau 2D, chaque « ligne » (et chaque « colonne ») contient le même nombre d’éléments. Exemple: int[][] grid = new int[3][5]; — nous avons toujours 3 lignes de 5 éléments.
- Dans un tableau irrégulier, chaque ligne peut avoir une longueur différente ! Exemple: int[][] jagged = new int[3][]; — et ensuite seulement nous initialisons chaque ligne (sous-tableau) comme on le souhaite.
Voici à quoi cela ressemble visuellement:
Tableau 2D (3x3):
┌───┬───┬───┐
│ 1 │ 2 │ 3 │
├───┼───┼───┤
│ 4 │ 5 │ 6 │
├───┼───┼───┤
│ 7 │ 8 │ 9 │
└───┴───┴───┘
Tableau irrégulier (longueurs différentes):
┌───┬───┐
│ 1 │ 2 │
├───┼───┼───┬───┐
│ 3 │ 4 │ 5 │ 6 │
├───┼───┴───┴───┘
│ 7 │
└───┘
2. Syntaxe de déclaration et d’initialisation d’un tableau irrégulier
Déclarer un tableau irrégulier n’est pas plus compliqué que de déclarer les types précédents ! Pas de panique devant la double paire de crochets:
int[][] jaggedArray = new int[3][];Cela signifie que nous avons un tableau de 3 éléments, et chacun d’eux est aussi un tableau de int. Mais pour l’instant, les tableaux internes ne sont pas créés ! Pour mieux comprendre, détaillons cela.
Initialisation pas à pas d’un tableau irrégulier
Étape 1 — création du tableau principal (externe):
int[][] jaggedArray = new int[3][];Nous avons maintenant 3 « lignes », mais elles valent toutes null pour l’instant.
Étape 2 — création et initialisation des tableaux internes (sous-tableaux):
Par exemple, que la première ligne ait une longueur de 2, la deuxième — 4, la troisième — 3:
jaggedArray[0] = new int[2]; // 2 éléments dans la première ligne
jaggedArray[1] = new int[4]; // 4 éléments dans la deuxième ligne
jaggedArray[2] = new int[3]; // 3 éléments dans la troisième ligne
Étape 3 — remplissage avec des valeurs:
Les tableaux internes sont des tableaux ordinaires ! Par exemple:
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 2;
jaggedArray[1][0] = 3;
jaggedArray[1][1] = 4;
jaggedArray[1][2] = 5;
jaggedArray[1][3] = 6;
jaggedArray[2][0] = 7;
jaggedArray[2][1] = 8;
jaggedArray[2][2] = 9;
Initialisation concise d’un tableau irrégulier
On peut créer et remplir un tableau irrégulier d’emblée, si vous connaissez les valeurs à l’avance:
int[][] jaggedArray = new int[][]
{
new int[] { 1, 2 },
new int[] { 3, 4, 5, 6 },
new int[] { 7, 8, 9 }
};
Ou un peu plus court, en omettant le type des tableaux internes:
int[][] jaggedArray =
{
{ 1, 2 },
{ 3, 4, 5, 6 },
{ 7, 8, 9 }
};
3. Parcours et travail avec les tableaux irréguliers
Parcourir un tableau irrégulier n’est pas plus compliqué qu’un tableau 2D, mais maintenant la boucle externe passe par les lignes, et la boucle interne parcourt les éléments de la ligne (qui peuvent avoir des longueurs différentes):
for (int i = 0; i < jaggedArray.length; i++)
{
System.out.println("Ligne " + i + ":");
for (int j = 0; j < jaggedArray[i].length; j++)
{
System.out.print(jaggedArray[i][j] + " ");
}
System.out.println();
}
Résultat à l’écran:
Ligne 0:
1 2
Ligne 1:
3 4 5 6
Ligne 2:
7 8 9
On peut utiliser for-each pour ne pas se soucier des indices:
for (int[] row : jaggedArray)
{
for (int value : row)
{
System.out.print(value + " ");
}
System.out.println();
}
4. Scénarios typiques d’utilisation des tableaux irréguliers
Quand un tableau irrégulier peut-il être plus utile qu’un tableau 2D ?
- Si vous stockez pour chaque utilisateur des quantités différentes de données: notes par matière, achats, commentaires, etc.
- Si vos données ont une structure triangulaire ou en escalier (par exemple, pour afficher des pyramides, les triangles de Pascal, etc.).
- Si vous souhaitez économiser de la mémoire: dans un tableau 2D, toutes les lignes sont fixes, alors que dans un tableau irrégulier — seulement le nombre d’éléments nécessaire.
Exemple concret: gestionnaire des notes des étudiants
Supposons que nous ayons trois étudiants, et voici leurs notes pour différents exercices de mathématiques:
| Étudiant | Notes |
|---|---|
| 0 | 5, 4 |
| 1 | 3, 4, 4 |
| 2 | 5 |
Déclarons un tel tableau:
int[][] studentMarks = new int[3][];
studentMarks[0] = new int[] { 5, 4 }; // Premier étudiant — 2 notes
studentMarks[1] = new int[] { 3, 4, 4 }; // Deuxième étudiant — 3 notes
studentMarks[2] = new int[] { 5 }; // Troisième étudiant — 1 note
Affichons les notes de chaque étudiant:
for (int i = 0; i < studentMarks.length; i++)
{
System.out.print("Étudiant " + i + ": ");
for (int j = 0; j < studentMarks[i].length; j++)
{
System.out.print(studentMarks[i][j] + " ");
}
System.out.println();
}
Utilisation des tableaux irréguliers avec d’autres types
Un tableau irrégulier peut contenir n’importe quoi: des chaînes, des tableaux d’autres tableaux (plus en profondeur !), voire vos propres objets.
Exemple: tableau de chaînes
String[][] groups = {
{ "John", "Peter" },
{ "Maria", "Alex", "Serge" },
{ "Sarah" }
};
5. Tableaux tridimensionnels et multidimensionnels
Encore un fait intéressant sur les tableaux, auquel vous vous doutez sans doute déjà. S’il est possible de faire un tableau 2D, peut-on faire un tableau 3D ?
Oui, on peut créer des tableaux de n’importe quelle dimension. De tels tableaux sont appelés multidimensionnels.
Comment déclarer des tableaux multidimensionnels
Il suffit d’indiquer le nombre de dimensions avec des paires de crochets:
int[][][] cube = new int[2][3][4]; // 2 couches, 3 lignes, 4 colonnes
cube[0][1][2] = 99;
Nous avons ici un tableau tridimensionnel:
- 2 éléments selon la première coordonnée,
- 3 — selon la deuxième,
- 4 — selon la troisième.
Un tel tableau est un grand « cube » de données, empaqueté séquentiellement.
Parcours d’un tableau 3D
L’accès à un élément se fait en utilisant tous les indices à la fois:
for (int i = 0; i < cube.length; i++)
{
for (int j = 0; j < cube[i].length; j++)
{
for (int k = 0; k < cube[i][j].length; k++)
{
System.out.print(cube[i][j][k] + " ");
}
System.out.println();
}
System.out.println("---");
}
- Les indices commencent à zéro, comme toujours en Java.
- Au total, ce tableau contient 2 × 3 × 4 = 24 éléments.
Exemples pratiques de tableaux multidimensionnels
- 2D — tableaux, échiquiers, images.
- 3D — « cubes » en infographie, données pour des calculs scientifiques (par exemple, la température en différents points de l’espace et du temps).
- 4D et plus — rarement utilisés, mais présents en mathématiques avancées, simulations, apprentissage automatique, etc.
6. Erreurs typiques lors du travail avec des tableaux multidimensionnels
Erreur n° 1: Dépassement des bornes du tableau
L’erreur la plus courante est d’essayer d’accéder à un élément inexistant, par exemple:
int[][] arr = new int[2][3];
arr[2][0] = 5; // Erreur ! Pas de ligne d’indice 2 (seulement 0 et 1)
arr[0][3] = 7; // Erreur ! Pas de colonne d’indice 3 (seulement 0, 1, 2)
Dans ce cas, le programme lèvera une ArrayIndexOutOfBoundsException. Vérifiez toujours que les indices sont dans les limites autorisées: de 0 à longueur - 1.
Erreur n° 2: Lignes non initialisées dans un tableau irrégulier
Si vous créez un tableau irrégulier et oubliez d’initialiser les tableaux internes, un accès provoquera une NullPointerException:
int[][] jagged = new int[3][];
jagged[0][0] = 5; // Erreur ! jagged[0] == null
Il faut d’abord créer le tableau interne: jagged[0] = new int[2];
Erreur n° 3: Mauvaise utilisation de la longueur du tableau
On confond matrix.length (nombre de lignes) et matrix[0].length (nombre de colonnes). Cela arrive souvent lors des copies, des parcours, ou des sommes par colonnes.
Erreur n° 4: Supposer que toutes les lignes ont la même longueur
Dans les tableaux irréguliers, les lignes peuvent avoir des longueurs différentes ! Si vous écrivez matrix[i][j], assurez-vous que j < matrix[i].length.
Erreur n° 5: Confusion dans l’ordre des indices
On confond parfois l’ordre: d’abord la ligne, puis la colonne: matrix[ligne][colonne]. Pas l’inverse !
GO TO FULL VERSION