Types de Boucles Imbriquées en Java

Vous pouvez imbriquer autant de for/while boucles comme vous le feriez pratiquement voulez en Java: il n'y a pas de limite pratique.

Java dispose de 4 boucles:

• JLS 14.14 Le for Déclaration
  • JLS 14.14.1 La base for Déclaration
  • JLS 14.14.2 Le renforcement de for Déclaration (aka "for-each")
• JLS 14.12 Le while Déclaration
• JLS 14.13 Le Déclaration (aka "do-while")

Java n'a pas goto (ce qui n'est pas vraiment nécessaire de toute façon).

Voir aussi

• Java des Écrous et des Boulons/le for Déclaration
• Le langage Java/guide de- de la boucle

---

Exemples

C'est un exemple typique d'un simple "triangle"-type de boucle imbriquée, où le nombre d'itération de la boucle interne dépend de la valeur itérée dans la boucle externe:

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

Voici un exemple d'un "jumelage"de type boucle imbriquée, où les deux boucles sont indépendants les uns des autres, en utilisant pour chaque construction:

int[] numbers = { 1, 2, 3 };                       //prints:  //if swapped:
char[] letters = { 'A', 'B', 'C' };                //1 A      //1 A
                                                   //1 B      //2 A
for (int number : numbers) {                       //1 C      //3 A
   for (char letter : letters) {                   //2 A      //1 B
       System.out.println(number + " " + letter);  //2 B      //2 B
   }                                               //2 C      //3 B
}                                                  //3 A      //1 C
                                                   //3 B      //2 C
                                                   //3 C      //3 C

La for-each construire, qui n'a pas explicite des indices, rend le indepedence de deux boucles évident: vous pouvez permuter deux for énoncés dans le code ci-dessus, et que vous souhaitez profiter de toutes les paires, bien qu'énumérés dans un ordre différent.

Cette utilisation d'un boolean méthode pour un while boucle (celle de java.util.Scanner) est typique:

Scanner sc = new Scanner("here we go again");     //prints:
while (sc.hasNext()) {                            //hereeeee
   String s = sc.next();                          //weeeee
   char lastChar = s.charAt(s.length() - 1);      //gooooo
   for (int i = 0; i < 4; i++) {                  //againnnnn
      s += lastChar;
   }
   System.out.println(s);
}

Et voici un exemple qui montre comment do-while est différente de while-do et for:

    int x = 0;
    do {
        System.out.println("Hello!!!");
    } while (x != 0);

Au-dessus de la boucle imprime Hello!!!: le corps d'un do-while est exécutée avant l'expiration condition est vérifiée.

---

Un exemple plus élaboré

Voici un exemple d'un sous-boucle logique, mais remaniée dans les méthodes pour rendre les choses plus lisibles. C'est quelque chose qui est important pour les débutants à apprendre: juste parce que vous pouvez physiquement nid de boucles autant de niveaux que vous le souhaitez, ne signifie pas que vous devriez. Par briser la logique de ce genre, le programme devient de plus en plus modulaire et lisible, et chaque logique se dresse sur ses propres et peut être testé et réutilisés, etc.

Cet extrait inverse les lettres d'un mot dans un char[] en place.

static void swap(char[] arr, int i, int j) {
    char t = arr[i];
    arr[i] = arr[j];
    arr[j] = t;
}
static void reverse(char[] arr, int from, int to) {
    int N = (to - from);
    for (int i = 0; i < N / 2; i++) {
        swap(arr, from+i, to-1-i);
    }
}
public static void main(String[] args) {
    char[] sentence = "reversing letters of words in sentence".toCharArray();
    final int L = sentence.length;
    int last = 0;
    for (int i = 0; i <= L; i++) {
        if ((i == L) || (sentence[i] == ' ')) {
            reverse(sentence, last, i);
            last = i + 1;
        }
    }
    System.out.println(new String(sentence));
    //prints "gnisrever srettel fo sdrow ni ecnetnes"
}

Cet exemple est aussi instructive que même si c'est essentiellement une boucle imbriquée à l'algorithme, c'est en fait O(N)! C'est une erreur de penser que l'doublement imbriquée de la boucle de l'algorithme doit être O(N^2) -- cela dépend vraiment de l'algorithme lui-même plus que la structure physique.

---

Nested loop Algorithmes de

Ce sont des algorithmes classiques traditionnellement mis en œuvre à l'aide de boucles imbriquées (au moins dans leur naïve formes):

• O(N^2) Algorithmes de tri:
  • Tri à bulles
  • Tri de la sélection
  • Le tri par Insertion
• O(N^3) triplement de boucle imbriquée algorithmes:
  • La multiplication de matrice
• Table de remplissage des algorithmes de programmation dynamique
  • Levenshtein (O(N^2), chaîne de distance d'édition)
  • De Floyd-Warshall Algorithme (O(N^3), toutes les paires de plus court chemin dans le graphe)

Elles sont loin d'être exhaustive d'échantillonnage, mais il doit fournir une bonne introduction à une variété de imbriquée for boucles d'algorithmes pour les débutants.

OriginalL'auteur polygenelubricants

Boucles peut être fait en utilisant les 3 de base de la boucle de déclarations: for, while et do..while.
Cependant, si votre question est sur le nombre de types de boucles imbriquées sont possible en Java, je dirais BEAUCOUP, puisque vous pouvez les organiser et de les mélanger comme vous le souhaitez.

OriginalL'auteur jweyrich

Je suppose que ça dépend du compilateur. J'ai écrit un programme de test simple qui génère des fichiers Java avec différents niveaux de boucle de nidification.

import java.io.BufferedWriter;
import java.io.FileWriter;

public class NestingTest
{
    public static void main(String[] args) throws Exception
    {
        for (int n = 1; n < 10000; ++n)
        {
            String className = "test" + n;
            FileWriter fw = new FileWriter("f:/test/" + className + ".java");
            BufferedWriter o = new BufferedWriter(fw);
            o.write("public class ");
            o.write(className);
            o.write("\n{\npublic static void main(String[] args) {\n");
            for (int i = 0; i < n; ++i)
            {
                o.write("while(true) {\n");
            }
            for (int i = 0; i < n; ++i)
            {
                o.write("}\n");
            }
            o.write("}\n}\n");
            o.close();
        }
    }
}

Une fois que les fichiers sont générés, vous faites un manuel de recherche binaire. Compiler test5000. Si elle réussit, compiler test7500, et si ça ne marche pas, compiler test2500. Après 13 ou 14 étapes, vous devriez venir à une conclusion.

Mon compilateur de la zone de frappe semble être 5345 niveaux d'imbrication pour ce programme simple, donc je suppose que, dans la pratique, il n'a pas d'importance du tout.

OriginalL'auteur fredoverflow