Boucles imbriquées et leur utilisation

1. Introduction

Commençons par une question : pourquoi a-t-on besoin d’imbriquer une boucle dans une autre ? Souvent, nos données ou nos tâches ne sont pas organisées en ligne, mais, par exemple, en tableau, en grille ou même en structure multidimensionnelle. Supposons que vous vouliez afficher la table de multiplication, parcourir un tableau 2D ou recalculer les intersections entre toutes les paires d’éléments. Ici, une seule boucle ne suffit clairement pas — il faut une boucle dans une boucle.

En programmation, une boucle imbriquée, c’est comme deux réveils : le réveil « extérieur » commence à sonner, et à l’intérieur, un autre se déclenche, qui sonnera à chaque fois tant que le premier est actif. Ainsi, pendant qu’une itération « extérieure » est en cours, l’itération intérieure suit entièrement son propre chemin (et le refait encore et encore pour chaque itération de l’extérieure).

Un bon exemple — les heures et les minutes. Les heures — c’est la boucle extérieure de 0 à 23, les minutes — la boucle intérieure de 0 à 59. À chaque changement de la boucle extérieure, l’intérieure a le temps de parcourir toutes ses valeurs.

2. Syntaxe des boucles imbriquées

En Java, la syntaxe des boucles imbriquées ne diffère pas de celle des boucles habituelles — vous écrivez simplement une boucle dans le corps d’une autre. Voyons des exemples avec for et while :

// Boucle externe for
for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 4; j++)  // Boucle interne for
    {
        System.out.print(i + "," + j + " ");
    }
    System.out.println(); // Saut de ligne après la boucle interne
}

Ici, la boucle extérieure contrôle la variable i (de 0 à 2), et l’intérieure — la variable j (de 0 à 3). Pour chaque valeur de i, la boucle intérieure parcourt entièrement de j == 0 à j == 3. Si vous exécutez ce code, vous verrez un joli tableau de coordonnées :

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

Exemple équivalent avec while :

int i = 0;
while (i < 3)
{
    int j = 0;
    while (j < 4)
    {
        System.out.print(i + "," + j + " ");
        j++;
    }
    System.out.println();
    i++;
}

Attention : à chaque passage de la boucle extérieure, la variable de la boucle intérieure (j) doit être réinitialisée, sinon nous ne verrons qu’une seule ligne !

3. Exemples d’utilisation des boucles imbriquées

Exemple 1 : affichage d’un échiquier (8×8)

Notre première tâche consiste à afficher un échiquier classique sous forme de cases noires et blanches (supposons que « # » — case noire, « . » — case blanche). Implémentons cela à l’aide de boucles for imbriquées :

for (int row = 0; row < 8; row++)
{
    for (int col = 0; col < 8; col++)
    {
        // Si la somme des indices ligne + colonne est paire — la case est blanche, sinon noire
        if ((row + col) % 2 == 0)
            System.out.print("_");
        else
            System.out.print("#");
    }
    System.out.println(); // Retour à la ligne après chaque rangée
}

Résultat :

_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_

Point important : l’imbrication garantit que pour chaque ligne (row) nous parcourons complètement toutes les colonnes (col). Sans imbrication, nous n’obtiendrions pas la structure d’un plateau — seulement une ligne ou une colonne.

Exemple 2 : table de multiplication

L’un des candidats classiques aux boucles imbriquées ! Affichons la table de multiplication de 1 à 9 :

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

Le formatage i * j + "\t" ajoute des tabulations pour que le tableau soit bien aligné.

Résultat :

  1   2   3   4   5   6   7   8   9 
  2   4   6   8  10  12  14  16  18 
  3   6   9  12  15  18  21  24  27 
  4   8  12  16  20  24  28  32  36 
...
  9  18  27  36  45  54  63  72  81 

4. Boucles imbriquées et leur contrôle — nuances

Influence de break et continue dans les boucles imbriquées

C’est ici que beaucoup de débutants se trompent ! Si vous utilisez break ou continue dans la boucle intérieure, ils n’affectent que cette boucle. L’extérieure continue de fonctionner comme si de rien n’était.

Exemple : sortie anticipée uniquement de la boucle interne

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (j == 3)
            break; // on sort uniquement de la boucle interne !
        System.out.print(i + "," + j + " ");
    }
    System.out.println();
}

Résultat :

0,0 0,1 0,2 
1,0 1,1 1,2 
2,0 2,1 2,2 

Si vous devez sortir immédiatement de deux boucles imbriquées (par exemple, terminer d’urgence une recherche au premier succès dans un tableau), on utilise généralement un drapeau (flag) ou une technique particulière (par exemple, return — si tout se passe dans une fonction).

5. Visualisation des boucles imbriquées

Il est parfois difficile de « voir » la séquence d’exécution des boucles imbriquées. Regardons le logigramme suivant :

Sous forme de tableau — combien d’itérations au total y aura-t-il pour i de 1 à 3, j de 1 à 4 ?

6. Erreurs et pièges lors de l’utilisation des boucles imbriquées

Erreur courante — mal initialiser la variable de la boucle intérieure. Par exemple, la déclarer en dehors de la boucle extérieure et ne pas la réinitialiser à chaque étape. Au final, la boucle intérieure peut ne pas s’exécuter du tout ou s’exécuter incorrectement.

int j = 0;
for (int i = 0; i < 3; i++)
{
    while (j < 4) // Oups ! j a déjà pu être égal à 4 après la première itération.
    {
        System.out.print(i + "," + j + " ");
        j++;
    }
    System.out.println();
}

Ici, la boucle ne s’exécutera qu’une seule fois. N’oubliez pas d’initialiser les variables des boucles intérieures à l’intérieur des boucles extérieures !

De plus, si vous écrivez par erreur deux boucles imbriquées avec les mêmes variables (for (int i = 0; ...) { for (int i = 0; ...) { ... } }), le compilateur vous signalera une erreur : la variable est déjà définie.