Les boucles en Java

• Initialisation
• Condition
• Mise à jour

1. Syntaxe de la boucle for :

for (initialisation; condition; mise à jour) {
    // code à exécuter
}

2. Exemple :

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

• Dans cet exemple, la variable i est initialisée à 0, la boucle continue tant que i est inférieur à 5, et i est incrémenté de 1 après chaque itération.

1. Syntaxe de la boucle while :

while (condition) {
    // code à exécuter
}

2. Exemple :

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

• Dans cet exemple, la boucle continue à s'exécuter tant que i est inférieur à 5. La variable i est incrémentée de 1 à chaque itération.
• Le bloc d’instruction, placé entre accolades juste après le while, sera exécuté tant que la condition est vraie.

3. Activivtés

1. Activivté:01

• Créer une boucle qui génère à chaque tour de boucle un nombre entier aléatoire entre 1 (compris) et 10. La boucle s'arrête quand un nombre supérieur à 7 est généré.
Solution

package boucle_while;

import java.util.Random;

public class while02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Random rand = new Random();
		int nb = 1;
		while (nb < 8) {
			nb = rand.nextInt(1, 10);
			System.out.println("Nombre généré : " + nb);
			}
	}

}




2. Activivté:02

• Le programme Java suivant implémente le jeu "Devinez un nombre". Dans ce jeu, l'ordinateur choisit un nombre aléatoire entre 0 et 1000, que le joueur doit deviner.
• À chaque proposition du joueur, l'ordinateur indique si le nombre proposé est plus grand ou plus petit que le nombre secret.
• L'objectif du jeu est de trouver le nombre secret le plus rapidement possible. Les concepts de programmation utilisés dans ce programme incluent :
• Utilisation d'une boucle while.
• Utilisation de la structure conditionnelle if pour tester les variables.
• Utilisation des opérateurs de comparaison (!=, <, et >).
• Saisie d'une chaîne de caractères depuis le clavier.
• Conversion d'une chaîne de caractères en un nombre réel.
• Conversion d'un nombre réel en un nombre entier.
• Initialisation d'une variable avec un nombre aléatoire compris entre 0 et 1000.
Solution

package boucle_while;

import java.util.Scanner;

public class jeux {

    public static void main(String[] args) {

        /* Déclaration des variables */
        int nombre_secret, int_nombre_propose;

        /* Initialisation des variables */
        int_nombre_propose = -1;

        /* Scanner pour lire l'entrée utilisateur */
        Scanner scanner = new Scanner(System.in);

        /* Choix d'un nombre au hasard entre 0 (inclus) et 1000 (non inclus) : */
        nombre_secret = (int) (Math.random() * 1000);
        int nbr_essaies=1;
        /* Début de la boucle while */
        while (int_nombre_propose != nombre_secret) {
            System.out.print("Entrez un nombre : ");

            /* Saisie d'un nombre entier depuis le clavier */
            int_nombre_propose = scanner.nextInt();

            /* Comparaison du nombre entier proposé avec le nombre secret */
            if (int_nombre_propose > nombre_secret)
                System.out.println("Le nombre cherché est plus petit que " + int_nombre_propose);
            else if (int_nombre_propose < nombre_secret)
                System.out.println("Le nombre cherché est plus grand que " + int_nombre_propose);
            nbr_essaies++;
        } /* Fin de la boucle while */

        System.out.println("Bravo, vous avez trouvé le nombre recherché après"+nbr_essaies+" essaies!");
        
        /* Fermeture du scanner */
        scanner.close();
    } /* Fin de la fonction main() */
} /* Fin de la classe */

1. Syntaxe de la boucle do-while :

do {
    // code à exécuter
} while (condition);

2. Exemple :

public class BoucleDoWhile {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("i vaut : " + i);
            i++;
        } while (i < 5);
    }
}

• Dans cet exemple, le bloc de code est exécuté une première fois, puis la condition est testée. La boucle continue tant que i est inférieur à 5.

public class BouclesImbriquees {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println("i vaut : " + i + ", j vaut : " + j);
            }
        }
    }
}

public class BoucleBreak {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // Sortie de la boucle
            }
            System.out.println("i vaut : " + i);
        }
    }
}

public class BoucleContinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                continue; // Passer à l'itération suivante
            }
            System.out.println("i vaut : " + i);
        }
    }
}

Boucle for :
Écrivez un programme qui affiche les nombres de 1 à 10.

Boucle while :
Écrivez un programme qui demande à l'utilisateur d'entrer des nombres et s'arrête lorsqu'il entre un nombre négatif.

Boucle do-while :
Écrivez un programme qui affiche les nombres de 1 à 5, même si la condition initiale est fausse.

Boucles Imbriquées :
Écrivez un programme qui affiche une table de multiplication de 1 à 5.

break et continue :
Écrivez un programme qui affiche les nombres de 1 à 10 mais saute les nombres multiples de 3 et s'arrête lorsqu'il atteint 8.