Se familiariser avec les boucles

for (initialisation; condition; mise à jour) {
    // corps de la boucle
}


Par exemple :

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

while (condition) {
    // corps de la boucle
}


Par exemple :

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

do {
    // corps de la boucle
} while (condition);


Par exemple :

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

Boucle For each

La boucle for-each en Java est une boucle améliorée qui permet de parcourir les éléments d’un tableau ou d’une collection de manière plus simple et plus concise que la boucle for traditionnelle. Elle est également appelée boucle for améliorée.

Voici un exemple de code qui utilise une boucle for-each pour parcourir un tableau d’entiers en Java:

int[] nombres = {1, 2, 3, 4, 5};
for (int nombre : nombres) {
    System.out.println(nombre);
}

Dans cet exemple, nous avons déclaré un tableau d’entiers appelé nombres et l’avons initialisé avec les valeurs {1, 2, 3, 4, 5}. Ensuite, nous avons utilisé une boucle for-each pour parcourir les éléments du tableau. La syntaxe de la boucle for-each est for (type variable : collection), où type est le type des éléments de la collection, variable est le nom de la variable qui stocke l’élément courant et collection est le nom de la collection à parcourir.

Dans notre exemple, la boucle for-each parcourt les éléments du tableau nombres et stocke chaque élément dans la variable nombre. À chaque itération de la boucle, la variable nombre prend la valeur de l’élément courant du tableau et le code à l’intérieur des accolades est exécuté. Dans notre cas, nous affichons simplement la valeur de la variable nombre.

La boucle for-each peut également être utilisée pour parcourir les éléments d’une collection telle qu’une liste ou un ensemble. Voici un exemple de code qui utilise une boucle for-each pour parcourir une liste de chaînes en Java:

List<String> fruits = Arrays.asList("Pomme", "Banane", "Orange");
for (String fruit : fruits) {
    System.out.println(fruit);
}

Dans cet exemple, nous avons déclaré une liste de chaînes appelée fruits et l’avons initialisée avec les valeurs "Pomme", "Banane" et "Orange". Ensuite, nous avons utilisé une boucle for-each pour parcourir les éléments de la liste. La syntaxe de la boucle for-each est la même que celle utilisée pour parcourir un tableau.

En résumé, la boucle for-each en Java est une boucle améliorée qui permet de parcourir les éléments d’un tableau ou d’une collection de manière simple et concise. Elle peut être utilisée à la place de la boucle for traditionnelle pour rendre le code plus lisible et plus facile à comprendre.

Sortir d'une boucle en Java

En Java, vous pouvez utiliser l’instruction break pour sortir d’une boucle. Voici comment cela fonctionne :

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

Dans cet exemple, la boucle for s’arrête lorsque i est égal à 5. Donc, cela n’imprimera que les nombres de 0 à 4.

Notez que l’instruction break arrête l’exécution de la boucle la plus interne dans laquelle elle est placée. Si vous avez des boucles imbriquées, elle n’arrêtera pas l’exécution des boucles extérieures. Pour sortir de plusieurs niveaux de boucles, vous devrez peut-être utiliser des étiquettes ou repenser la logique de votre programme.

Continuer à la prochaine itération d'une boucle en Java

En Java, vous pouvez utiliser l’instruction continue pour passer à la prochaine itération d’une boucle. Voici comment cela fonctionne :

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue;
    }
    System.out.println(i);
}

Dans cet exemple, lorsque i est égal à 5, l’instruction continue est exécutée. Cela fait que la boucle passe immédiatement à la prochaine itération, donc 5 n’est pas imprimé. Les nombres de 0 à 4 et de 6 à 9 sont imprimés.

Notez que l’instruction continue, comme l’instruction break, n’affecte que la boucle la plus interne dans laquelle elle est placée. Si vous avez des boucles imbriquées, elle ne passera pas à la prochaine itération des boucles extérieures.

Comment puis-je sortir de plusieurs boucles imbriquées en Java?

En Java, pour sortir de plusieurs boucles imbriquées, vous pouvez utiliser des étiquettes de boucle en combinaison avec l’instruction break. Voici comment cela fonctionne :

outerLoop: // Ceci est une étiquette de boucle
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i * j > 10) {
            break outerLoop; // Ceci sort de la boucle outerLoop
        }
        System.out.println(i + ", " + j);
    }
}

Dans cet exemple, outerLoop est une étiquette qui est associée à la boucle for externe. Lorsque l’instruction break outerLoop; est exécutée, le contrôle est transféré à l’instruction suivant immédiatement la boucle outerLoop, ce qui signifie que toutes les boucles imbriquées sont terminées.

Notez que les étiquettes de boucle peuvent être utilisées avec n’importe quelle instruction de bloc, pas seulement les boucles. Elles peuvent également être utilisées avec l’instruction continue pour passer à la prochaine itération d’une boucle externe. Cependant, leur utilisation peut rendre le code plus difficile à comprendre et à maintenir, il est donc généralement préférable d’éviter d’utiliser des étiquettes de boucle sauf lorsque cela est absolument nécessaire.

Utiliser des étiquettes de boucle en Java?

En Java, les étiquettes de boucle peuvent être utilisées pour contrôler le flux d’exécution dans les boucles imbriquées. Voici comment vous pouvez les utiliser :

outer: // Ceci est une étiquette de boucle
for (int i = 0; i < 5; i++) {
    inner: // Une autre étiquette de boucle
    for (int j = 0; j < 5; j++) {
        if (j == 2) {
            continue outer; // Continue avec la prochaine itération de la boucle outer
        }
        System.out.println("i: " + i + ", j: " + j);
    }
}

Dans cet exemple, outer et inner sont des étiquettes associées à des boucles for. Lorsque l’instruction continue outer; est exécutée, le contrôle est transféré à la prochaine itération de la boucle outer, en sautant le reste du code dans la boucle inner.

De même, vous pouvez utiliser l’instruction break avec une étiquette pour sortir d’une boucle spécifique :

outer: // Ceci est une étiquette de boucle
for (int i = 0; i < 5; i++) {
    inner: // Une autre étiquette de boucle
    for (int j = 0; j < 5; j++) {
        if (j == 2) {
            break outer; // Sort de la boucle outer
        }
        System.out.println("i: " + i + ", j: " + j);
    }
}

Dans cet exemple, lorsque l’instruction break outer; est exécutée, le contrôle sort de la boucle outer, en terminant toutes les itérations restantes dans les deux boucles.

Notez que l’utilisation d’étiquettes peut rendre le code plus difficile à lire et à comprendre, il est donc généralement recommandé de les utiliser avec parcimonie.