Dans cette section, vous allez apprendre à utiliser les boucles en Java. Les boucles permettent de répéter un bloc de code plusieurs fois, ce qui est essentiel pour traiter des collections de données, effectuer des calculs répétitifs, ou créer des programmes interactifs. Vous découvrirez les boucles for, while et do-while.

3.2Les boucles

3.2.1 – Boucle for

La boucle for est utilisée quand vous savez à l'avance combien de fois vous voulez répéter une instruction. C'est la boucle la plus couramment utilisée en Java.

🔄 Structure de base : for

Syntaxe :

for (initialisation; condition; incrémentation) {
    // Code à répéter
}

Exemple : Afficher les nombres de 1 à 5

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

// Affiche :
// 1
// 2
// 3
// 4
// 5

📝 Composants de la boucle for

Initialisation : Exécutée une seule fois au début (ex: int i = 0)
Condition : Évaluée avant chaque itération (ex: i < 10)
Incrémentation : Exécutée après chaque itération (ex: i++)

📊 Exemples pratiques

Exemple 1 : Compter de 0 à 9

for (int i = 0; i < 10; i++) {
    System.out.println("Itération " + i);
}

Exemple 2 : Compter à rebours

for (int i = 10; i >= 1; i--) {
    System.out.println(i);
}
// Affiche : 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

Exemple 3 : Compter par pas de 2

for (int i = 0; i <= 10; i += 2) {
    System.out.println(i);
}
// Affiche : 0, 2, 4, 6, 8, 10

Exemple 4 : Calculer la somme

int somme = 0;

for (int i = 1; i <= 100; i++) {
    somme += i;
}

System.out.println("Somme de 1 à 100 : " + somme);  // 5050

🔀 Boucle for améliorée (for-each)

La boucle for-each permet de parcourir facilement des tableaux et collections :

Syntaxe :

for (type element : collection) {
    // Utiliser element
}

Exemple : Parcourir un tableau

int[] nombres = {10, 20, 30, 40, 50};

for (int nombre : nombres) {
    System.out.println(nombre);
}

// Équivalent à :
for (int i = 0; i < nombres.length; i++) {
    System.out.println(nombres[i]);
}

💡 Points clés à retenir

for : Utilisé quand le nombre d'itérations est connu
Structure : initialisation; condition; incrémentation
for-each : Parcourt facilement tableaux et collections
Variable de boucle : Portée limitée à la boucle
Incrémentation : Peut être ++, --, +=, -=, etc.

3.2.2 – Boucles while et do-while

Les boucles while et do-while sont utilisées quand vous ne savez pas à l'avance combien de fois vous devez répéter une instruction. La différence principale est que while vérifie la condition avant d'exécuter, tandis que do-while exécute au moins une fois avant de vérifier.

🔄 Boucle while

Syntaxe :

while (condition) {
    // Code à répéter tant que la condition est vraie
}

Exemple : Compter jusqu'à 5

int i = 1;

while (i <= 5) {
    System.out.println(i);
    i++;  // Important : ne pas oublier d'incrémenter !
}

// Affiche : 1, 2, 3, 4, 5

📝 Exemples pratiques avec while

Exemple 1 : Menu interactif

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
int choix = 0;

while (choix != 3) {
    System.out.println("1. Option 1");
    System.out.println("2. Option 2");
    System.out.println("3. Quitter");
    System.out.print("Votre choix : ");
    choix = scanner.nextInt();
    
    if (choix == 1) {
        System.out.println("Vous avez choisi l'option 1");
    } else if (choix == 2) {
        System.out.println("Vous avez choisi l'option 2");
    }
}

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

Exemple 2 : Calculer la puissance

int base = 2;
int exposant = 5;
int resultat = 1;
int i = 0;

while (i < exposant) {
    resultat *= base;
    i++;
}

System.out.println("2^5 = " + resultat);  // 32

🔄 Boucle do-while

La boucle do-while exécute le code au moins une fois, puis vérifie la condition :

Syntaxe :

do {
    // Code à répéter
} while (condition);

Exemple : Demander une saisie valide

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
int nombre;

do {
    System.out.print("Entrez un nombre positif : ");
    nombre = scanner.nextInt();
} while (nombre <= 0);

System.out.println("Merci ! Vous avez entré : " + nombre);

📊 Comparaison : while vs do-while

Critère	while	do-while
Vérification	Avant l'exécution	Après l'exécution
Exécutions minimales	0 (peut ne jamais s'exécuter)	1 (s'exécute au moins une fois)
Cas d'usage	Quand la condition peut être fausse dès le début	Quand vous voulez exécuter au moins une fois

⚠️ Boucles infinies

Attention aux boucles infinies ! Une boucle infinie se produit quand la condition reste toujours vraie :

Exemple de boucle infinie (à éviter !) :

int i = 1;

while (i <= 5) {
    System.out.println(i);
    // Oubli de i++ ! La boucle ne s'arrêtera jamais !
}

// Solution : Toujours modifier la variable de condition
int i = 1;

while (i <= 5) {
    System.out.println(i);
    i++;  // ✅ Ne pas oublier !
}

🛑 Contrôle des boucles : break et continue

break : Sortir de la boucle

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;  // Sort de la boucle
    }
    System.out.println(i);
}
// Affiche : 1, 2, 3, 4

continue : Passer à l'itération suivante

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;  // Passe à l'itération suivante
    }
    System.out.println(i);
}
// Affiche : 1, 3, 5, 7, 9 (nombres impairs seulement)

💡 Points clés à retenir

while : Répète tant que la condition est vraie (vérifie avant)
do-while : Répète tant que la condition est vraie (vérifie après, exécute au moins une fois)
Boucle infinie : Toujours modifier la variable de condition
break : Sort immédiatement de la boucle
continue : Passe à l'itération suivante
Choix : Utilisez for si le nombre d'itérations est connu, while/do-while sinon

Conseil pratique : Pour éviter les boucles infinies, assurez-vous toujours que la condition de la boucle peut devenir fausse. Vérifiez que vous modifiez les variables utilisées dans la condition.