Réponse.

Les boucles imbriquées permettent d'exécuter une séquence de boucles à l'intérieur d'une autre. Elles sont utilisées lorsque l'on doit parcourir des structures multidimensionnelles, comme des tableaux bidimensionnels ou des combinaisons d'éléments. La première boucle est appelée externe, et celle qui est à l'intérieur est appelée interne.

Historique de la question

Le besoin de travailler avec des structures imbriquées, comme des matrices ou des graphes, a conduit à l'émergence des boucles imbriquées. Les langages de programmation, y compris Java, supportent ce mécanisme dès le départ afin de programmer des tâches de traitement de tableaux, de graphes, de maillages, etc.

Problème

L'utilisation de boucles imbriquées peut entraîner une complexité temporelle élevée si l'on ne tient pas compte du nombre d'itérations. Des problèmes de lisibilité du code et d'erreurs d'indexation se posent souvent. Une utilisation incorrecte entraîne l'exécution répétée des mêmes actions.

Solution

Utilisez les boucles imbriquées uniquement lorsque cela est nécessaire — par exemple, pour les tableaux bidimensionnels.
Faites attention aux variables de boucle, évitez les conflits de noms.
Évaluez la complexité : une boucle imbriquée dans une autre boucle sur n éléments donnera O(n^2) actions.

Exemple de code :

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

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

Caractéristiques clés :

Chaque niveau de boucle augmente la complexité d'exécution du programme.
Il est important de distinguer les volumes d'initialisation, les conditions de sortie et le travail avec les compteurs.
Dans les tâches modernes, il est souvent possible d'optimiser les boucles imbriquées et de les remplacer par des algorithmes ou des flux de données.

Questions pièges.

Peut-on interrompre les deux boucles en même temps avec break ?

L'opérateur break habituel ne termine que la boucle interne. Pour sortir immédiatement de plusieurs boucles, on utilise des étiquettes (label) :

outer:
for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        if (condition) break outer;
    }
}

Un cycle infini est-il possible à cause de boucles imbriquées ?

Oui, si la condition de sortie de l'une des boucles est mal mise en œuvre, un cycle infini se produira. Cela se produit souvent en raison d'erreurs dans l'initialisation ou l'incrémentation du compteur.

Peut-on modifier les variables de la boucle externe depuis la boucle interne ?

Oui, techniquement, cela est possible, mais cela nuit fortement à la lisibilité et entraîne des erreurs. Il est préférable d'éviter cela et de séparer explicitement le travail de chaque boucle.

Erreurs typiques et anti-patterns

Erreurs d'indexation (débordement de tableau).
Niveau d'imbrication injustifié.
Utilisation de mêmes noms de variables pour différents niveaux de boucles.
Condition de sortie incorrecte.

Exemple de la vie réelle

Cas négatif

On implémente un parcours d'un tableau bidimensionnel, mais au lieu de i et j, on utilise i partout :

for (int i = 0; i < n; i++) {
    for (int i = 0; i < m; i++) {...}
}

Avantages :

Approche simple et compréhensible pour parcourir tous les éléments.

Inconvénients :

La boucle interne crée chaque fois un nouvel i, perdant la valeur de l'externe.
La logique s'effondre, ce qui provoque un cycle infini ou incorrect.

Cas positif

On utilise des noms de variables différents :

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {...}
}