📘 Le cours : répéter en Java
Une boucle répète un bloc d'instructions. Pour qu'elle soit correcte, elle a besoin de trois ingrédients : un départ, une condition d'arrêt et un pas qui rapproche de cet arrêt. Il manque l'un des trois et la boucle ne s'arrête jamais ou ne démarre pas.
La boucle for
for (init; condition; pas) : l'initialisation a lieu une seule fois, la condition est testée avant chaque tour, le pas est exécuté après chaque tour.
public class Table7 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println("7 x " + i + " = " + (7 * i));
}
}
}
Affichage7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
Le pas peut être n'importe quoi : i += 2, ou i -= 3 pour compter à rebours.
public class Rebours {
public static void main(String[] args) {
for (int i = 10; i > 0; i -= 3) {
System.out.print(i + " ");
}
System.out.println();
}
}
Convention
Pour parcourir un tableau t, écris for (int i = 0; i < t.length; i++) : les indices vont de 0 à t.length - 1, donc la condition est < et jamais <=.
La boucle while
while (condition) convient quand on ne sait pas à l'avance combien de tours seront nécessaires. Ici, on additionne les chiffres de 2845 en prenant le dernier (n % 10) puis en le retirant (n /= 10).
public class Chiffres {
public static void main(String[] args) {
int n = 2845;
int somme = 0;
while (n > 0) {
somme += n % 10; // dernier chiffre
n /= 10; // on le retire
}
System.out.println(somme); // 5 + 4 + 8 + 2
}
}
do … while : au moins un tour
Le test est fait après le bloc, ce qui convient pour redemander une saisie tant qu'elle est invalide. N'oublie pas le ; final.
import java.util.Scanner;
public class SaisieValide {
public static void main(String[] args) {
Scanner clavier = new Scanner(System.in);
int n;
do {
System.out.print("Un nombre entre 1 et 10 : ");
n = clavier.nextInt();
} while (n < 1 || n > 10);
System.out.println("Merci : " + n);
}
}
Si tu tapes 42 puis 7Un nombre entre 1 et 10 : 42
Un nombre entre 1 et 10 : 7
Merci : 7
La boucle for-each
Pour parcourir tous les éléments d'un tableau (ou d'une collection), la boucle for (Type x : structure) est plus lisible : pas d'indice à gérer, donc pas d'erreur d'un cran. Elle ne convient pas quand tu as besoin de l'indice ou de modifier les éléments d'un tableau de nombres.
public class ForEach {
public static void main(String[] args) {
int[] notes = {12, 15, 9, 18};
int somme = 0;
for (int note : notes) {
somme += note;
}
System.out.println("somme = " + somme);
System.out.println("moyenne = " + (double) somme / notes.length);
}
}
Affichagesomme = 54
moyenne = 13.5
break et continue
break quitte la boucle ; continue abandonne le tour en cours et passe au suivant. while (true) crée une boucle sans fin que l'on arrête de l'intérieur avec break.
public class Interruption {
public static void main(String[] args) {
int somme = 0;
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue; // on saute les pairs
}
somme += i;
}
System.out.println("somme des impairs : " + somme);
int n = 51;
while (true) {
if (n % 7 == 0) {
break; // on arrête la boucle
}
n++;
}
System.out.println("premier multiple de 7 apres 50 : " + n);
}
}
Affichagesomme des impairs : 25
premier multiple de 7 apres 50 : 56
Boucles imbriquées
Pour chaque tour de la boucle extérieure, la boucle intérieure recommence depuis le début.
public class Triangle {
public static void main(String[] args) {
for (int ligne = 1; ligne <= 4; ligne++) {
String etoiles = "";
for (int k = 0; k < ligne; k++) {
etoiles += "*";
}
System.out.println(etoiles);
}
}
}
Avec n lignes, la boucle intérieure s'exécute 1 + 2 + … + n fois : le coût croît comme n², la complexité quadratique de T(n) et O(). Depuis Java 11, "*".repeat(ligne) remplace la boucle intérieure.
