Les boucles imbriquées en Java

Une boucle imbriquée est une boucle placée à l'intérieur d'une autre boucle. La boucle interne s'exécute jusqu'à la fin à chaque passage de la boucle externe, de sorte que le corps s'exécute outer × inner fois. C'est la structure de base pour tout problème impliquant des lignes et des colonnes, des paires ou des données multidimensionnelles.

Ce chapitre suppose que vous connaissez les formes de base des boucles — la boucle for et la boucle while. N'importe quelle boucle peut être imbriquée dans une autre ; les exemples ci-dessous utilisent for car c'est la plus courante, mais la règle est la même pour while et for-each.

Deux boucles for

for (int i = 1; i <= 3; i++) {
  for (int j = 1; j <= 3; j++) {
    System.out.println(i + "," + j);
  }
}

Sortie :

1,1
1,2
1,3
2,1
2,2
2,3
3,1
3,2
3,3

Pour chaque valeur de i, la boucle interne parcourt j de 1 à 3 avant que i n'avance. Notez que j est réinitialisé à 1 à chaque passage extérieur — la boucle interne repart de zéro à chaque répétition de la boucle externe. Gardez les variables de boucle distinctes (i et j ici) ; réutiliser le même nom dans les deux boucles est une source courante de bogues.

Parcourir un tableau 2D

L'utilisation classique des boucles imbriquées est d'itérer sur une matrice :

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

for (int r = 0; r < grid.length; r++) {
  for (int c = 0; c < grid[r].length; c++) {
    System.out.print(grid[r][c] + " ");
  }
  System.out.println();
}

Chaque ligne de la grille est elle-même un tableau ; la boucle externe itère sur les lignes, la boucle interne itère sur les cellules de chaque ligne. La forme for-each est encore plus lisible quand vous n'avez pas besoin des indices :

for (int[] row : grid) {
  for (int cell : row) {
    System.out.print(cell + " ");
  }
  System.out.println();
}

Afficher des motifs

Les boucles imbriquées sont un exercice classique pour afficher des motifs. Un triangle d'étoiles :

int rows = 5;
for (int i = 1; i <= rows; i++) {
  for (int j = 1; j <= i; j++) {
    System.out.print("*");
  }
  System.out.println();
}

Sortie :

*
**
***
****
*****

Le nombre d'itérations de la boucle interne dépend de la variable de la boucle externe — un schéma puissant que l'on retrouve constamment.

Attention à la complexité

Une seule boucle sur n éléments s'exécute n fois. Une boucle imbriquée à l'intérieur s'exécute n × n = n² fois. Trois boucles imbriquées s'exécutent n³ fois. Pour un petit n, cela n'a pas d'importance ; pour un grand n, cela en a beaucoup :

Si votre boucle imbriquée porte sur un grand ensemble de données, demandez-vous si vous avez vraiment besoin de la boucle interne. Une recherche dans une HashMap remplace souvent une boucle de recherche interne et transforme O(n²) en O(n).

break et continue n'affectent que la boucle interne

Nous avons vu cela dans break et continue : sans étiquette, les deux s'appliquent uniquement à la boucle la plus interne. Pour sortir de la boucle externe ou ignorer son itération depuis l'intérieur de la boucle interne, utilisez un break ou continue étiqueté — voir les instructions étiquetées.

Un exemple concret

Et ensuite

Lorsque vous avez besoin de break ou continue sur une boucle externe depuis l'intérieur d'une boucle interne, les instructions étiquetées vous offrent un moyen propre de le faire.

Pratique