Les boucles en Java

Maîtriser les structures conditionnelles (if, while). Connaître les opérateurs arithmétiques et relationnels. Avoir des notions de base sur les tableaux.

Objectifs

Comprendre le principe d'itération. Maîtriser les trois boucles Java : for, while et do-while. Savoir choisir la boucle adaptée selon le contexte et éviter les boucles infinies.

1. Principe des boucles

Définition — Boucle Une boucle (ou structure itérative) permet de répéter l'exécution d'un bloc d'instructions tant qu'une condition est vraie. Elle est composée de trois éléments : une initialisation, une condition d'arrêt et une mise à jour de la variable de contrôle.

Type	Boucles concernées	Condition testée	Exécution minimale
Entrée contrôlée	`for`, `while`	Avant le corps	0 fois (si condition fausse dès le départ)
Sortie contrôlée	`do-while`	Après le corps	1 fois minimum (toujours)

Boucle infinie Une boucle dont la condition ne devient jamais false s'exécute indéfiniment et bloque le programme. Les causes les plus fréquentes : oublier la mise à jour de la variable de contrôle, ou utiliser un opérateur de comparaison incorrect.

// Boucle infinie — i n'est jamais mis à jour
while (i < 5) {
    System.out.println(i); // i reste à 0 pour toujours !
}

2. La boucle `for`

Définition — for La boucle for est une structure de répétition à nombre d'itérations connu à l'avance. Elle regroupe dans son en-tête les trois composantes : initialisation, condition et mise à jour.

Syntaxe — for Java

for (initialisation ; condition ; mise à jour) {
    // bloc d'instructions répété tant que condition == true
}

2.1 Fonctionnement pas à pas

Étape	Description	Exemple
1 — Initialisation	Exécutée une seule fois avant la boucle	`int i = 0`
2 — Condition	Testée avant chaque itération. Si `false`, la boucle s'arrête	`i < 5`
3 — Corps	Exécuté si la condition est `true`	`System.out.println(i)`
4 — Mise à jour	Exécutée après chaque itération, puis retour à l'étape 2	`i++`

Exemple 1 — Afficher les entiers de 0 à 4

public class BoucleFor {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

Sortie

i = 0
i = 1
i = 2
i = 3
i = 4

Complément — Variantes de la boucle for

// Décompte : de 10 à 1
for (int i = 10; i >= 1; i--) {
    System.out.print(i + " ");
}
// Sortie : 10 9 8 7 6 5 4 3 2 1

// Pas de 2
for (int i = 0; i <= 10; i += 2) {
    System.out.print(i + " ");
}
// Sortie : 0 2 4 6 8 10

// Variable de boucle inaccessible après la boucle
// int j = i; // Erreur : i n'existe plus ici

Portée de la variable de boucle Une variable déclarée dans l'initialisation du for (int i = 0) n'existe que dans la boucle. Elle n'est pas accessible après l'accolade fermante. Pour y accéder après, déclarez-la avant la boucle.

3. La boucle `for-each` (for améliorée)

Définition — for-each Introduite en Java 5, la boucle for-each parcourt séquentiellement tous les éléments d'un tableau ou d'une collection sans gérer d'index manuellement. Elle rend le code plus lisible et moins sujet aux erreurs.

Syntaxe — for-each Java

for (type element : tableau_ou_collection) {
    // traitement sur element
}

Exemple 2 — Parcourir un tableau avec for-each

public class BoucleForEach {
    public static void main(String[] args) {
        int[] T = {3, 6, 7, 2, 1};

        for (int elem : T) {
            System.out.println(elem);
        }
    }
}

Sortie

3.1 Comparaison for classique vs for-each

Critère	`for` classique	`for-each`
Accès à l'index	Oui (`i`)	Non
Modification des éléments	Oui (`T[i] = val`)	Non (copie locale)
Parcours partiel	Oui (plage d'indices)	Non (tout le tableau)
Lisibilité	Moyenne	Excellente
Risque d'erreur d'index	Possible (`ArrayIndexOutOfBoundsException`)	Aucun

Limitation — Modification impossible Dans une boucle for-each, la variable elem est une copie locale de l'élément. Modifier elem ne modifie pas le tableau original :

int[] T = {1, 2, 3};
for (int elem : T) {
    elem *= 2; // Ne modifie PAS T !
}
// T est toujours {1, 2, 3}

// Pour modifier, utiliser le for classique :
for (int i = 0; i < T.length; i++) {
    T[i] *= 2; // Modifie T[i] correctement
}

4. La boucle `while`

Définition — while La boucle while répète un bloc tant que sa condition est true. La condition est évaluée avant chaque itération : si elle est fausse dès le départ, le corps n'est jamais exécuté.

Syntaxe — while Java

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

Exemple 3 — Afficher les entiers de 0 à 4 avec while

public class BoucleWhile {
    public static void main(String[] args) {
        int i = 0; // initialisation

        while (i < 5) { // condition
            System.out.println("i = " + i);
            i++; // mise à jour
        }
    }
}

Sortie

i = 0
i = 1
i = 2
i = 3
i = 4

Application — Lecture jusqu'à saisie valide

Le while est particulièrement adapté quand le nombre d'itérations dépend d'une condition externe (saisie utilisateur, lecture de fichier…) :

import java.util.Scanner;

Scanner sc = new Scanner(System.in);
int saisie = -1;

while (saisie < 0 || saisie > 100) {
    System.out.print("Entrez une note entre 0 et 100 : ");
    saisie = sc.nextInt();
}
System.out.println("Note valide : " + saisie);

5. La boucle `do-while`

Définition — do-while La boucle do-while exécute le corps de la boucle au moins une fois, puis évalue la condition. Si elle est true, le corps est répété. La condition est testée en sortie de boucle.

Syntaxe — do-while Java

initialisation;
do {
    // corps de la boucle
    mise à jour;
} while (condition); // ← point-virgule obligatoire !

Point-virgule obligatoire La boucle do-while se termine par } while (condition);. Le point-virgule après la parenthèse fermante est obligatoire. Son absence provoque une erreur de compilation.

Exemple 4 — do-while : toujours exécuté au moins une fois

public class BoucleDoWhile {
    public static void main(String[] args) {
        int i = 0; // initialisation

        do {
            System.out.println("i = " + i);
            i++; // mise à jour
        } while (i < 5); // condition
    }
}

Sortie

i = 0
i = 1
i = 2
i = 3
i = 4

Exemple 5 — Différence while vs do-while (condition fausse dès le départ)

int i = 10;

// while : condition false dès le départ → corps jamais exécuté
while (i < 5) {
    System.out.println("while : " + i);
}
System.out.println("Après while : aucune itération");

// do-while : corps exécuté UNE fois avant de tester
do {
    System.out.println("do-while : " + i);
} while (i < 5);
System.out.println("Après do-while : une itération");

Sortie

Après while : aucune itération
do-while : 10
Après do-while : une itération

Application — Menu interactif

Le do-while est idéal pour les menus : le menu doit toujours s'afficher au moins une fois avant de vérifier si l'utilisateur veut quitter.

import java.util.Scanner;

Scanner sc = new Scanner(System.in);
int choix;

do {
    System.out.println("=== MENU ===");
    System.out.println("1. Afficher");
    System.out.println("2. Calculer");
    System.out.println("0. Quitter");
    System.out.print("Votre choix : ");
    choix = sc.nextInt();
} while (choix != 0);

System.out.println("Au revoir !");

6. Instructions de contrôle de boucle

6.1 `break` — sortir d'une boucle

break L'instruction break interrompt immédiatement la boucle courante et transfère le contrôle à l'instruction qui suit la boucle.

// Chercher la première valeur négative dans un tableau
int[] T = {3, 5, -2, 7, 1};
int premierNegatif = -1;

for (int val : T) {
    if (val < 0) {
        premierNegatif = val;
        break; // sortir dès la première valeur négative trouvée
    }
}
System.out.println("Premier négatif : " + premierNegatif);

Sortie

Premier négatif : -2

6.2 `continue` — passer à l'itération suivante

continue L'instruction continue ignore le reste du corps de la boucle pour l'itération courante et passe directement à la prochaine évaluation de la condition.

// Afficher uniquement les entiers pairs de 0 à 9
for (int i = 0; i < 10; i++) {
    if (i % 2 != 0) {
        continue; // ignorer les impairs
    }
    System.out.print(i + " ");
}

Sortie

0 2 4 6 8

7. Boucles imbriquées

Définition — Boucle imbriquée Une boucle peut contenir une autre boucle dans son corps. La boucle interne effectue toutes ses itérations pour chaque itération de la boucle externe.

Exemple 6 — Table de multiplication

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 5; j++) {
        System.out.printf("%3d", i * j);
    }
    System.out.println(); // retour à la ligne après chaque ligne
}

Sortie

  1  2  3  4  5
  2  4  6  8 10
  3  6  9 12 15

8. Choisir la bonne boucle

Règle de choix

Utilisez for quand le nombre d'itérations est connu à l'avance (parcourir un tableau de taille connue, répéter N fois).
Utilisez for-each pour parcourir séquentiellement un tableau ou une collection sans besoin de l'index.
Utilisez while quand le nombre d'itérations est inconnu mais la condition d'arrêt est connue (lecture jusqu'à EOF, attente d'une condition).
Utilisez do-while quand le corps doit s'exécuter au moins une fois (menu, validation de saisie).

9. Exercice

Statistiques d'un tableau

Niveau : Débutant

Écrire un programme Java qui calcule et affiche plusieurs statistiques sur un tableau d'entiers donné.

Travail demandé

Utiliser une boucle for-each pour calculer la somme des éléments.
Utiliser une boucle for classique pour trouver le maximum et son index.
Utiliser une boucle while pour compter le nombre d'éléments strictement positifs.
Calculer et afficher la moyenne (avec deux décimales).

Exemple avec T = {5, -3, 8, 2, -1, 7}

Sortie

Somme    : 18
Maximum  : 8 (indice 2)
Positifs : 4
Moyenne  : 3.00

Contraintes

Utiliser obligatoirement les trois types de boucles (for-each, for classique, while)
Afficher la moyenne avec printf("%.2f", ...)
Initialiser le maximum avec le premier élément du tableau

Solution détaillée

public class StatistiquesTableau {
    public static void main(String[] args) {

        int[] T = {5, -3, 8, 2, -1, 7};

        // ── 1. Somme avec for-each ────────────────────────
        int somme = 0;
        for (int elem : T) {
            somme += elem;
        }

        // ── 2. Maximum et son indice avec for classique ───
        int max    = T[0];
        int indMax = 0;
        for (int i = 1; i < T.length; i++) {
            if (T[i] > max) {
                max    = T[i];
                indMax = i;
            }
        }

        // ── 3. Nombre de positifs avec while ──────────────
        int positifs = 0;
        int j = 0;
        while (j < T.length) {
            if (T[j] > 0) positifs++;
            j++;
        }

        // ── 4. Moyenne ────────────────────────────────────
        double moyenne = (double) somme / T.length;

        // ── Affichage ─────────────────────────────────────
        System.out.println("Somme    : " + somme);
        System.out.println("Maximum  : " + max + " (indice " + indMax + ")");
        System.out.println("Positifs : " + positifs);
        System.out.printf("Moyenne  : %.2f%n", moyenne);
    }
}

Résultat :

Sortie

Somme    : 18
Maximum  : 8 (indice 2)
Positifs : 4
Moyenne  : 3.00

Points clés :

for-each : idéal pour calculer la somme — pas besoin de l'index.
for classique : indispensable pour trouver l'index du maximum.
while : équivalent au for quand on veut séparer initialisation et condition.
Cast (double) : nécessaire avant la division pour obtenir un résultat décimal et non entier.
T.length : propriété d'un tableau Java donnant sa taille — évite les erreurs d'index.

L'essentiel en bref

Java propose trois boucles principales. La boucle for est préférable quand le nombre d'itérations est connu à l'avance ; la variante for-each simplifie le parcours séquentiel de tableaux et collections. La boucle while convient quand la condition d'arrêt dépend d'un événement imprévisible — le corps peut ne jamais s'exécuter si la condition est fausse dès le départ. La boucle do-while garantit au moins une exécution du corps, idéale pour les menus et les validations de saisie. Les instructions break et continue permettent de contrôler finement le déroulement des itérations.

Sortie

// La sortie apparaîtra ici…

Prêt · Ctrl+Entrée pour exécuter

Précédent Les structures conditionnelles en Java

Suivant Instructions de saut : break, continue et return

Discussion (0)

Soyez le premier à laisser un commentaire !

Laisser un commentaire

Votre commentaire sera visible après modération.

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

Les boucles en Java