Boucle imbriquée en Java

Les boucles constituées d'une autre boucle à l'intérieur sous la forme d'une structure semblable à un nid sont construites, et la boucle externe surveille le nombre d'exécutions de la boucle interne, les boucles fonctionnant dans une telle structure appelée boucle imbriquée. On l'appelle également une boucle à l'intérieur de la boucle.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Syntaxe de la boucle imbriquée en Java

Voici les différentes syntaxes :

1. Boucle For imbriquée

for(initialize;cond1;increment/decrement)
{
for(initialize;cond2;increment/decrement)
{
//body of loop2
}
//body of loop1
}

2. Boucle While imbriquée

while(cond1)
{
while(cond2)
{
// body of loop2
}
//body of loop1
}

3. Boucle Do-while imbriquée

do{
do{
//body of loop 2
}while(cond2)
//body of loop 1
}while(cond1

4. Boucle hétérogène imbriquée

L'imbrication de la boucle n'a aucune limitation : seuls des types de boucles similaires peuvent être imbriqués. Nous pouvons imbriquer n'importe quelle boucle dans n'importe quelle autre boucle, comme while inside for boucle ou while boucle à l'intérieur de la boucle do-while et toutes les autres combinaisons possibles sont toutes applicables.

for(initialize;cond1;increment/decrement)
{
while(cond2){
//body of loop2
}
// body of loop1
}

Organigramme

Explication :

Dans l'organigramme ci-dessus, d'abord, lorsque nous entrons dans le corps du programme, une instruction telle que les instructions d'initialisation ou d'impression est exécutée. Une fois qu'une boucle est trouvée, le programme vérifie la condition de la boucle externe ; s'il renvoie vrai, il entre dans la boucle ; sinon, la boucle est terminée et le reste des instructions du programme après la boucle s'exécute.

Une fois qu'il entre dans la boucle externe et rencontre la boucle interne, les variables sont initialisées le cas échéant, suivies de la vérification de la condition de la boucle interne si elle renvoie vrai. Le programme entre dans la boucle interne ; sinon, revenez à la fin de Loop1 et effectuez une incrémentation/décrémentation pour exécuter à nouveau Loop1.

Dans le cas où cond2 renvoie vrai, les instructions Loop2 sont exécutées et la variable compteur est incrémentée/décrémentée. Cette procédure est répétée plusieurs fois, puis le programme quitte Loop2, puis Loop1 et passe aux instructions présentes après la boucle.

Comment Fonctionne Nested Loop en Java ?

Chaque boucle se compose de 3 éléments ci-dessous :

1. Initialisation : Cette étape fait référence à l'initialisation de la valeur du compteur.
2. Condition : Cette condition fait référence à la comparaison qui doit être vraie pour continuer l'exécution de la boucle.
3. Incrément/Décrément du compteur : Il s'agit de l'opération à effectuer sur le compteur une fois qu'un flux de boucle est terminé.

Dans le cas de boucles imbriquées, les trois étapes ci-dessus sont vérifiées pour chaque boucle à l'intérieur. Ainsi, à chaque flux de la boucle externe, la boucle interne s'exécute complètement, ce qui signifie que si nous avons m flux pour la boucle externe et n nombre de flux pour la boucle externe, alors cette boucle ensemble sera exécutée m*n fois.

Remarque : Il n'y a aucune limitation sur le nombre de boucles qui peuvent être imbriquées ainsi que sur le type de boucles qui peuvent être imbriquées, on peut utiliser n'importe quel type de boucle, mais il faut faire attention car cela affecte le complexité temporelle du programme et affecte ainsi les performances.

Par exemple :

for(int i=0;i<5;i++){
for(int j=0;j<5;j++){
System.out.println(“LOOP DEMO”);
}
}

Dans le cas de la boucle imbriquée donnée ci-dessus :

Boucle extérieure

Counter variable = i
Condition – i<5
Increment/decrement – i++

Boucle intérieure

Counter variable = j
Condition – j<5
Increment/decrement – j++

Exemples de boucle imbriquée en Java

Vous trouverez ci-dessous des exemples de boucles imbriquées en Java :

Exemple n°1

Écrivons un programme pour imprimer le modèle ci-dessous :

*

**

***

****

*****

Code :

package Try;
class Demo
{
//static method
public static void main(String[] args)
{
for(int i=0;i<5;i++){
for(int j=0;j<5;j++){
if(i>=j) {
System.<em>out</em>.print('*');}
}
System.<em>out</em>.println("\n");
}
}
}

Sortie : Explication :

Dans le programme ci-dessus, 2 boucles internes sont utilisées puisque le motif qui doit être imprimé peut être pris comme un tableau 2D avec '*' comme élément avec 5 lignes et 5 colonnes.

De plus, la condition if(i<=j) peut être déterminée en utilisant les emplacements de * présents dans le tableau 2D où le compteur pour les lignes est I et pour les colonnes, nous utilisons j.

	I=1	I=2	I=3	I=4	I=5
J=1	*
J=2	*	*
J=3	*	*	*
J=4	*	*	*	*
J=5	*	*	*	*	*

We can easily configure that we need to print * only when i

Example #2

Let’s see the example to print a 2D matrix.

Code:

package Try;
class Demo
{
public static void printMatrix(int arr[][][]){
int i=0,j=0;
while(i<arr.length){
while(j<arr[i].length){
for (int k = 0; k <arr[j].length; k++)
System.out.println("arr[" + i + "][" + j + "]["+ k + "] = "+arr[i][j][k] );
j++;
}
i++;
j=0;
}
}
public static void main(String[] args)
{
int arr[][][] ={ { { 10, 2 }, { 30, 4 } }, { { 51, 6 }, { 79, 8 } } };
printMatrix(arr);
}
}

Output:

Explanation:
In the above program, we have used 3 loops to print the elements stored in a 3D Matrix using 3 counter variables. Thus, any number of loops can be tested as well as any type of loop can be used.

Conclusion

Nested loop refers to the placement of loop inside the loop to execute the operations that need multiple loop traversals such as printing star patterns or search operations on any collection data structure array or linked list. Although it helps to make our task easier, it also increases the complexity of the program thus must be used in an efficient manner.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!