Conditions et boucles en Java

Une condition est de type boolean : elle produit true ou false. Java a besoin de ce résultat explicite dans une condition de if ou de boucle. Un entier seul n’est pas une condition, donc while (count) ne compile pas ; count > 0 pose une question claire dont la réponse est vraie ou fausse.

Compare des nombres et des caractères

Avec int a = 7; et int b = 10;, a < b et a != b valent true, tandis que a >= b vaut false. Des types numériques différents peuvent être comparés : 3 == 3.0 vaut true après que Java a converti l’entier en double par conversion élargissante.

Une comparaison de char utilise les numéros de code Unicode. Par exemple, 'a' < 'b' vaut true. C’est aussi le cas de 'Z' < 'a' : leurs codes sont 90 et 97. Dans cet ordre, toutes les lettres majuscules ASCII de A à Z précèdent les lettres minuscules de a à z.

Stocke une réponse utile

int age = 17;
boolean isAdult = age >= 18;
System.out.println(isAdult);

La comparaison donne false, qui est stocké dans isAdult puis affiché. Un nom qui a un sens permet au code suivant d’écrire directement if (isAdult).

Distingue l’affectation de la comparaison. = stocke une valeur ; == compare des valeurs. Pour un entier, if (x = 5) échoue, car l’affectation produit un entier. Pour un booléen, if (done = true) compile, affecte true à done et exécute la branche. Pour tester l’indicateur existant, écris if (done).

Compare du texte et des nombres décimaux calculés

Utilise command.equals("quit") pour comparer les caractères d’une chaîne. Le texte saisi « quit » correspond ; « Quit » ne correspond pas. Utilise equalsIgnoreCase lorsque la casse ne doit pas compter et !command.equals("quit") pour vérifier que le texte est différent. L’opérateur == vérifie si les chaînes désignent le même objet : il ne convient donc pas pour comparer le contenu d’une saisie utilisateur.

La représentation binaire en virgule flottante ne permet pas de stocker exactement de nombreuses fractions décimales. 0.1 + 0.2 produit 0.30000000000000004, donc 0.1 + 0.2 == 0.3 vaut false. Une comparaison avec tolérance vérifie l’écart entre les valeurs calculées :

double sum = 0.1 + 0.2;
boolean closeEnough = Math.abs(sum - 0.3) < 1e-9;

Ici, Math.abs rend la différence positive ou nulle ; la très petite différence est inférieure à 1e-9, donc closeEnough vaut true. Choisis une tolérance adaptée à la précision requise par le calcul. Les comparaisons exactes de valeurs int ne présentent pas de problème d’arrondi en virgule flottante.

Teste la divisibilité et les intervalles

n % 3 == 0 vérifie si un entier est divisible par 3. Pour les nombres impairs, utilise n % 2 != 0 : le test inclut les valeurs impaires négatives, puisque -7 % 2 vaut -1.

Écris séparément chaque partie d’un test d’intervalle : 0 < x && x < 10. Java ne peut pas lire 0 < x < 10 comme une chaîne de comparaisons mathématiques : la première comparaison produit déjà un booléen, qui ne peut pas être comparé à 10.

Les opérateurs logiques combinent des conditions complètes, vraies ou fausses. Lis une condition composée comme une règle portant sur les données, puis teste des valeurs qui devraient la respecter et d’autres qui ne devraient pas la respecter.

Relie et nie des tests

&& signifie et : les deux parties doivent être vraies. || signifie ou : au moins une partie doit être vraie, y compris lorsque les deux le sont. ! signifie non et inverse une valeur booléenne.

| p | q | p && q | p || q | | --- | --- | --- | --- | | true | true | true | true | | true | false | false | true | | false | true | false | true | | false | false | false | false |

Pour une température confortable de 18 à 24 °C inclus, il faut tester les deux bornes : temp >= 18 && temp <= 24. Être hors de cet intervalle signifie temp < 18 || temp > 24. Relier les bornes de l’intervalle avec || accepte tous les nombres : en dessous de 18, le test de la borne supérieure est vrai, et au-dessus de 24, le test de la borne inférieure est vrai.

Chaque opérande doit être une expression booléenne. Écris x == 1 || x == 2, car x == 1 || 2 place un entier là où un booléen est requis. Pour un entier, !x > 5 n’est pas valide ; !(x > 5) nie toute la comparaison.

Évalue uniquement ce qui est nécessaire

Java évalue && et || de gauche à droite et court-circuite l’évaluation lorsque la partie gauche détermine le résultat. Avec &&, un côté gauche faux fait ignorer le côté droit. Avec ||, un côté gauche vrai le fait ignorer.

int total = 36;
int count = 0;
boolean largeAverage = count != 0 && total / count > 10;

La première comparaison est fausse, donc la division est ignorée et largeAverage prend la valeur false. Inverse les opérandes et la division a lieu avant la condition de garde ; une division entière par zéro lève une ArithmeticException. Place la vérification de sécurité avant le calcul qu’elle protège.

Rends le regroupement visible

De la plus forte à la plus faible, les priorités des opérateurs concernés sont : !, les comparaisons d’ordre (<, <=, >, >=), les comparaisons d’égalité (==, !=), &&, puis ||. Ainsi, a || b && c se regroupe sous la forme a || (b && c). Lorsque a est vrai et que b et c sont faux, cette expression est vraie ; (a || b) && c est fausse. Les parenthèses montrent la règle voulue.

Les lois de De Morgan déplacent une négation à travers une condition composée :

• !(p && q) équivaut à !p || !q.
• !(p || q) équivaut à !p && !q.

Nie chaque partie et intervertis l’opérateur qui les relie. Appliqué à l’intervalle de température, cela donne !(temp >= 18 && temp <= 24) équivalent à temp < 18 || temp > 24.

Exprime une règle avec une exception

Dans le calendrier grégorien, une année bissextile est divisible par 4, sauf qu’une année séculaire doit être divisible par 400 :

boolean leap = (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;

La première partie accepte 2024. Elle rejette 1900 parce que 1900 est une année séculaire ; le dernier test accepte 2000 parce qu’elle est divisible par 400. L’année 2026 ne satisfait aucune des deux parties.

Des booléens nommés facilitent la lecture des tests plus longs, comme isWeekend || isHoliday. Pour deux booléens, ^ est le OU exclusif : un seul opérande doit être vrai, comme avec !=. Les opérateurs simples & et | calculent aussi le et et le ou booléens, mais évaluent les deux opérandes ; utilise && et || pour les conditions évaluées en court-circuit.

Un if exécute un bloc lorsque sa condition est vraie. Un if avec un else choisit exactement l’un de deux blocs. Une fois le bloc choisi terminé, l’exécution continue avec l’instruction suivante.

Choisis un chemin

int age = 16;
if (age >= 18) {
    System.out.println("Adult ticket");
} else {
    System.out.println("Youth ticket");
}
System.out.println("Next customer");

La condition est fausse, donc la sortie est « Youth ticket », suivi de « Next customer ». La dernière instruction n’appartient à aucune des deux branches. Place la condition booléenne entre parenthèses et les instructions de chaque branche entre accolades.

Sans accolades, seule l’instruction suivante appartient à un if. L’indentation ne regroupe pas le code. Dans cet exemple incorrect, le deuxième message apparaît pour chaque score :

if (score < 50)
    System.out.println("Not passed");
    System.out.println("Try again");

Des accolades autour des deux instructions d’affichage rendent les deux conditionnelles. Une autre erreur consiste à placer un point-virgule immédiatement après la condition : if (x > 10); a un corps vide. Un bloc qui le suit s’exécute indépendamment et un else placé après ce bloc indépendant n’a pas de if correspondant.

Garde un résultat disponible

Une variable déclarée dans un bloc n’est visible qu’à l’intérieur de ce bloc. Déclare un résultat avant les branches lorsque le code suivant en a besoin :

String ticket;
if (age >= 18) {
    ticket = "Adult ticket";
} else {
    ticket = "Youth ticket";
}
System.out.println(ticket);

Les deux chemins possibles affectent une valeur à ticket, donc son affichage ensuite est valide. Si seule la branche correspondant à la condition vraie lui affectait une valeur, Java rejetterait sa lecture ultérieure : la variable pourrait ne pas avoir été initialisée. Déclarer ticket séparément dans chaque branche ne laisserait pas non plus de ticket disponible après la décision.

Place une décision dans une autre

Un if imbriqué n’exécute son test que lorsque l’exécution atteint la branche qui le contient :

if (hasTicket) {
    if (age < 12) {
        System.out.println("Child seat");
    } else {
        System.out.println("Standard seat");
    }
} else {
    System.out.println("Buy a ticket first");
}

Une personne sans billet atteint le else externe ; la vérification de l’âge est ignorée. Si les deux tests imbriqués ne font que protéger la même action et qu’aucun des deux n’a de else, ils peuvent devenir if (hasTicket && age < 12).

La règle du else pendant rattache un else au if le plus proche qui n’a pas encore de branche alternative. Sans accolades, l’aligner visuellement sur un if externe ne change pas cette règle. Pour un test externe vérifiant que x est positif, suivi d’un test interne vérifiant que y est positif, le else suivant appartient au test de y. Des accolades autour de toute la décision interne sont nécessaires lorsque le else doit appartenir au test externe.

Choisis une valeur avec ?:

L’opérateur conditionnel choisit l’une de deux valeurs :

int n = 7;
String label = n % 2 == 0 ? "even" : "odd";

La condition est fausse, donc l’expression donne « odd ». Sa forme est condition ? valueIfTrue : valueIfFalse. Utilise-le pour un choix court entre deux valeurs ; utilise un if lorsque les branches effectuent plusieurs actions. Des expressions conditionnelles imbriquées rendent rapidement le chemin choisi difficile à suivre.

Un enchaînement de else if teste les conditions dans l’ordre et sélectionne la première qui est vraie. Une fois cette branche exécutée, les conditions restantes sont ignorées. Un else final traite les valeurs restantes ; sans lui, l’enchaînement peut n’effectuer aucune action.

Ordonne des seuils qui se chevauchent

Pour des scores de 0 à 100, teste d’abord la note la plus élevée :

String grade;
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else if (score >= 60) {
    grade = "D";
} else {
    grade = "F";
}

Pour 85, le premier test échoue et le deuxième réussit. Le programme affecte « B » sans vérifier les seuils restants. Atteindre score >= 80 signifie déjà que le score est inférieur à 90 : une borne supérieure supplémentaire est donc inutile.

Si score >= 60 apparaissait en premier, chaque score permettant de réussir recevrait « D ». Va du cas correspondant le plus restrictif vers les cas plus larges. Cet ordre compte, car plusieurs conditions peuvent être vraies même si une seule branche s’exécute.

Traite d’abord le cas combiné

FizzBuzz comporte un cas particulier où deux règles se chevauchent : les multiples de 3 et de 5 doivent donner « FizzBuzz ». Teste ce cas avant chacun des tests de divisibilité pris séparément :

if (n % 15 == 0) {
    System.out.println("FizzBuzz");
} else if (n % 3 == 0) {
    System.out.println("Fizz");
} else if (n % 5 == 0) {
    System.out.println("Buzz");
} else {
    System.out.println(n);
}

Le test % 15 == 0 accepte 30 ; 9 mène à « Fizz », 10 à « Buzz » et 7 à la branche finale. Commencer par % 3 == 0 accepterait 30 trop tôt et n’afficherait que « Fizz ».

Choisis un résultat ou plusieurs actions

Des instructions if distinctes sont des décisions indépendantes. Avec x = 15, un if (x > 10) peut afficher « big » et un if (x > 0) placé ensuite peut aussi afficher « positive ». Les relier avec else if rend le second test inaccessible chaque fois que le premier est vrai. Utilise des tests indépendants lorsque les deux actions peuvent être nécessaires ; utilise un enchaînement pour sélectionner un seul résultat.

Vérifie les bornes et les valeurs invalides

Un enchaînement pour une température entière avec temp < 10, puis temp > 10 && temp < 25, puis temp >= 25 oublie 10 exactement. Remplace le deuxième test par temp < 25 : l’atteindre signifie déjà que le premier test a échoué, donc que la valeur est au moins égale à 10. Un else final traite alors 25 et les valeurs supérieures.

Pour chaque seuil, essaie la valeur juste en dessous, le seuil lui-même et la valeur juste au-dessus. Pour l’enchaînement des scores, 89, 90 et 91 révèlent si la borne de A est correctement incluse. Teste aussi les limites globales.

Valide un score avant de lui attribuer une note : place score < 0 || score > 100 en premier et signale « Invalid score » dans ce cas. Les branches suivantes ne traitent alors que des scores valides ; 150 ne peut pas recevoir « A » par accident. La validation est un premier cas distinct, et non une correction après le choix de la note.

Un switch sélectionne un cas en comparant une valeur à des étiquettes fixes. Il convient aux commandes nommées et aux choix numérotés. Utilise un enchaînement de else if lorsque le choix dépend d’un intervalle ou de plusieurs variables.

Fais correspondre des valeurs exactes

Un switch sur une valeur accepte des sélecteurs char, byte, short, int, leurs types enveloppes, String et les types énumérés. Sans fonctionnalités expérimentales, les sélecteurs long, float, double et boolean ne sont pas pris en charge. Les étiquettes doivent être des constantes : une condition comme score >= 90 n’est pas une étiquette de valeur.

switch (day) {
    case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
    case 6, 7 -> System.out.println("Weekend");
    default -> System.out.println("Invalid day");
}

Un cas avec flèche n’exécute que son propre code, sans enchaînement vers le cas suivant. Les virgules regroupent plusieurs étiquettes pour une action. Un jour égal à 6 affiche « Weekend » ; un jour égal à 9 ne correspond à aucune valeur listée et affiche « Invalid day ».

Les étiquettes de chaînes correspondent à un contenu exact, sensible à la casse. Une commande « Start » ne correspond pas à case "start". Une étiquette en double provoque une erreur de compilation, et un même switch ne peut pas mélanger des cas avec flèche et des cas avec deux-points.

Produis une valeur

Une expression switch calcule un résultat :

int days = switch (month) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    case 2 -> 28;
    default -> 0;
};

Dans une année non bissextile, le mois 9 donne 30, le mois 2 donne 28 et le mois invalide 13 donne 0. Le point-virgule après l’accolade fermante termine la déclaration de la variable.

Une expression doit être exhaustive : chaque valeur possible du sélecteur doit avoir un résultat. Pour ces exemples avec int et String, inclus default. Une instruction switch sur une valeur peut omettre default ; une valeur sans correspondance n’exécute alors aucun cas. Une expression qui produit une valeur ne peut pas simplement omettre de produire son résultat.

Donne un résultat à un bloc avec yield

Un cas qui effectue un calcul avant de choisir sa valeur nécessite un bloc :

int days = switch (month) {
    case 2 -> {
        boolean leap = (year % 4 == 0 && year % 100 != 0)
                || year % 400 == 0;
        yield leap ? 29 : 28;
    }
    case 4, 6, 9, 11 -> 30;
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    default -> 0;
};

yield fournit la valeur du cas à l’expression switch. Février donne 29 en 2024 et 28 en 2026. Une seule expression après une flèche, comme case 2 -> 28;, n’a pas besoin de yield.

Lis l’ancienne forme avec deux-points

switch (level) {
    case 1:
        System.out.println("Bronze");
    case 2:
        System.out.println("Silver");
        break;
    case 3:
        System.out.println("Gold");
        break;
}

Pour le niveau 1, l’exécution entre dans le premier cas et continue dans le deuxième, affichant à la fois « Bronze » et « Silver ». C’est l’enchaînement des cas : une étiquette avec deux-points n’arrête pas l’exécution. break termine le switch. Des étiquettes successives avec deux-points peuvent partager volontairement une action ; un break manquant après une action peut exécuter accidentellement la suivante.

Un switch sur char peut regrouper 'a', 'e', 'i', 'o', 'u' pour donner « vowel », avec default donnant « other ». Le même principe de valeur exacte s’applique aux caractères, aux commandes et aux choix numériques.

Une boucle while teste sa condition avant chaque passage. Si la condition est vraie, Java exécute le corps et revient au test. Si elle est fausse, l’exécution continue après la boucle. Un premier test faux signifie qu’il n’y a aucun passage.

Suis le départ, le test, le corps et la mise à jour

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

La valeur initiale est 1. Chaque passage affiche la valeur actuelle puis l’augmente. Le cinquième passage affiche 5 et porte i à 6. Le test suivant est faux, donc la boucle se termine. Le corps s’exécute cinq fois, mais la condition est testée six fois : une fois avant chaque passage et une dernière fois avec un résultat faux.

Une boucle de comptage a besoin d’une valeur initiale, d’un test et d’une mise à jour qui la rapproche de l’arrêt. Sans i++, cette boucle affiche 1 indéfiniment. Un point-virgule placé par erreur est un autre piège : dans while (i <= 5);, l’instruction vide est le corps. Lorsque i commence dans l’intervalle, le bloc suivant n’est jamais atteint et ne peut pas le mettre à jour.

Arrête-toi lorsqu’une limite est franchie

L’égalité est souvent un test d’arrêt fragile. En partant de 0 et en ajoutant 3, on obtient 0, 3, 6, 9, 12, et ainsi de suite. Le test i != 10 ne peut pas détecter le franchissement de 10, car 10 est sauté. Le test i < 10 termine la boucle après le traitement de 9. Choisis une borne qui correspond au sens de la mise à jour.

Certaines boucles se répètent un nombre inconnu de fois. Par exemple :

int amount = 1;
int days = 0;
while (amount < 1000) {
    amount *= 2;
    days++;
}

Chaque passage double la quantité et compte un jour. Après neuf passages, elle vaut 512 ; après dix, elle vaut 1 024. Le test faux à 1 024 laisse days égal à 10. Une boucle peut se terminer au-dessus de son seuil lorsque la mise à jour avance par pas plus grands.

Lis avant de décider de t’arrêter

while (true) {
    String line = scanner.nextLine();
    if (line.equals("stop")) {
        break;
    }
    System.out.println("You wrote: " + line);
}

Ici, scanner est le Scanner utilisé pour la saisie. La boucle lit une ligne, vérifie si elle contient « stop » et ne réaffiche que les lignes ordinaires. La commande d’arrêt est lue, mais pas traitée. while (true) a besoin d’une sortie accessible pour se terminer ; une boucle qui continue à se répéter sans sortir est une boucle infinie.

Suis les changements d’état

Considère un produit :

int n = 3;
int product = 1;
while (n > 0) {
    product *= n;
    n--;
}

La multiplication utilise l’ancienne valeur de n, puis la décrémentation a lieu. Déplacer la décrémentation avant la multiplication changerait les valeurs multipliées.

Déclare un résultat cumulé avant la boucle pour qu’il soit conservé d’un passage à l’autre. Une variable déclarée dans le corps est créée à nouveau chaque fois que l’exécution atteint sa déclaration. Affiche le résultat dans le corps pour voir les résultats intermédiaires ; affiche-le après l’accolade fermante pour montrer une fois le résultat final.

Une boucle do-while exécute le corps avant de vérifier si un autre passage est nécessaire. Utilise-la lorsque la première action doit avoir lieu, par exemple pour afficher un menu ou demander une valeur à saisir.

Teste après la première action

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

Le corps affiche 10 et incrémente i jusqu’à 11. Ce n’est qu’ensuite que Java teste i < 5. La condition est fausse, donc il n’y a pas de deuxième passage. Une boucle while (i < 5) partant de 10 n’afficherait rien.

Le point-virgule après le while (...) final est obligatoire. Il termine l’instruction do-while. Cela diffère du point-virgule placé par erreur après l’en-tête d’un while à test initial, qui crée un corps de boucle vide.

Répète tant que la saisie est invalide

int rating;
do {
    System.out.print("Rating (1-5): ");
    rating = Integer.valueOf(scanner.nextLine());
} while (rating < 1 || rating > 5);

L’invite apparaît avant la première vérification : l’utilisateur peut donc fournir la valeur à vérifier. Avec les saisies 7, puis 0, puis 4, les deux premières évaluations de la condition sont vraies et déclenchent une nouvelle invite. La dernière est fausse, donc la boucle se termine avec rating égal à 4.

La condition décrit la poursuite de la boucle, pas l’acceptation. Une note valide satisfait rating >= 1 && rating <= 5. La boucle se répète tant que cette expression est fausse, ce que les lois de De Morgan réécrivent sous la forme rating < 1 || rating > 5. Une conjonction entre ces bornes extérieures ne serait jamais vraie : un nombre ne peut pas être inférieur à 1 et supérieur à 5 en même temps.

Déclare la variable vérifiée avant le bloc

L’accolade fermante termine la portée du corps avant l’évaluation de la condition. Une déclaration comme int rating dans le bloc do ne serait donc pas accessible dans la condition finale. Déclare la variable avant do et affecte-lui la saisie dans le corps. L’affectation s’exécute toujours avant le premier test.

Le même placement compte lorsque la valeur acceptée est utilisée ensuite. rating reste accessible après toute la boucle et contient alors la dernière valeur lue.

Garde un menu ouvert

String choice;
do {
    System.out.println("a: show status, q: quit");
    choice = scanner.nextLine();
    if (choice.equals("a")) {
        System.out.println("Ready");
    }
} while (!choice.equals("q"));

Chaque passage affiche le menu et lit un choix. Saisir « a » affiche « Ready » et répète la boucle. Saisir « q » saute l’action et met fin à la boucle au niveau de la condition. Une commande inconnue provoque aussi une répétition, car elle n’est pas « q ».

Lorsque son corps ne contient aucun continue ciblant la boucle, une boucle do-while peut être réécrite avec while (true) et un break en bas du corps, associé à la condition niée. Un continue demande une attention particulière dans une telle réécriture : dans la boucle do-while d’origine, il passe à la condition, tandis que dans une boucle while-true, il revient en haut et peut sauter ce test ajouté en bas.

Une boucle for regroupe le contrôle d’un comptage dans un seul en-tête. Elle est utile lorsque tu connais l’intervalle ou le nombre de passages avant le début de la répétition.

Lis l’en-tête dans l’ordre d’exécution

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

L’initialisation s’exécute une fois et affecte 1 à i. Java teste i <= 5, exécute le corps si la condition est vraie, exécute i++ et revient au test. La mise à jour est écrite dans l’en-tête, mais s’exécute après le corps. Le dernier test faux termine la boucle.

Pour un comptage ordinaire, i++ et ++i ont le même effet à l’emplacement de la mise à jour, car la valeur d’aucune des deux expressions n’est utilisée. Garde les modifications du compteur dans l’en-tête pour que la suite soit facile à prévoir.

Choisis la première et la dernière valeur

Pour des pas croissants d’une unité, lorsque la borne de fin est supérieure ou égale à celle de départ, une borne de fin exclue donne un nombre de passages égal à la fin moins le départ ; une borne de fin incluse ajoute un passage. Avec des pas plus grands, il faut lister ou compter les valeurs réellement atteintes. Une boucle décroissante doit tester dans le sens correspondant : partir de 10 avec i <= 1 ne donne aucun passage.

Une erreur de décalage d’une unité inclut ou exclut une borne à tort. Pour afficher les nombres de 1 à 10, i < 10 oublie 10 ; utilise i <= 10. Vérifie la première valeur utilisée dans le corps, la dernière et la première valeur qui ne satisfait pas la condition.

Construis un résultat sur un intervalle

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

Le corps ajoute chaque entier une fois et se termine à 5 050. Un produit commence différemment : initialise product à 1 avant de multiplier par les nombres de 1 à 5. Cela donne 120 ; commencer à 0 laisserait le produit à 0 après chaque multiplication.

Surveille la portée et les corps vides

Un compteur déclaré dans l’en-tête existe pendant toute la boucle, mais pas après son accolade fermante. Déclare-le plus tôt si le code suivant a besoin de sa valeur finale.

Un point-virgule immédiatement après l’en-tête constitue un corps vide. Dans for (int i = 0; i < 3; i++);, l’instruction vide s’exécute trois fois. Un bloc suivant qui affiche « Hello » s’exécute une fois après la boucle, pas trois fois. Les accolades se placent directement après l’en-tête.

Toute partie de l’en-tête peut être omise. for (;;) { ... } n’a pas de condition d’arrêt et se comporte comme while (true) ; il lui faut une sortie comme break pour se terminer.

Choisis la boucle la plus claire

Les formes peuvent exprimer la même répétition, mais les réécritures doivent préserver l’ordre des tests et des mises à jour, y compris ce qu’un continue saute.

Une sortie anticipée peut arrêter la répétition dès que sa tâche est accomplie. Sauter un passage peut éviter un traitement inutile tout en poursuivant la boucle. Suis attentivement leurs destinations : break et continue ont des rôles différents.

Termine une recherche avec break

for (int n = 51; n <= 100; n++) {
    if (n % 7 == 0) {
        System.out.println(n);
        break;
    }
}

Les valeurs de 51 à 55 échouent au test de divisibilité. La valeur suivante, 56, est affichée et break quitte immédiatement la boucle. La mise à jour ne s’exécute pas après ce break. Sans lui, les multiples suivants comme 63 et 70 seraient aussi affichés.

Un break sans étiquette cible la boucle ou le switch englobant le plus proche. L’exécution continue après cette construction, pas après l’ensemble du programme.

Saute un passage avec continue

for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        continue;
    }
    System.out.print(i + " ");
}

Pour 3, 6 et 9, continue saute l’instruction d’affichage. Dans une boucle for, la mise à jour de l’en-tête s’exécute tout de même, suivie de la condition. La sortie contient 1, 2, 4, 5, 7, 8 et 10.

Pour une boucle while ou do-while, continue passe à la condition. Toute mise à jour placée en dessous dans le corps est sautée. Si un compteur while commence à 0 et que la première action est if (i % 3 == 0) { continue; }, un i++ placé plus loin dans le corps n’est jamais atteint. Le compteur reste à 0 et la boucle se répète indéfiniment. Déplace la mise à jour nécessaire avant chaque chemin qui saute la suite, ou utilise un en-tête for pour que la mise à jour reste automatique.

Quitte volontairement des boucles imbriquées

Un break ordinaire dans une boucle interne ne termine que cette boucle interne. Une étiquette peut désigner une boucle externe comme cible de sortie :

outer:
for (int a = 1; a <= 10; a++) {
    for (int b = 1; b <= 10; b++) {
        if (a * b == 24 && a + b == 10) {
            System.out.println("Found " + a + " and " + b);
            break outer;
        }
    }
}

La recherche parcourt les paires dans l’ordre. Pour a = 4 et b = 6, les deux tests réussissent et le break étiqueté quitte les deux boucles. continue outer passerait à la mise à jour de la boucle externe, puis à son test suivant.

Distingue les sorties du switch de celles de la boucle

Dans une boucle de menu contenant un switch sous forme avec deux-points, break dans un cas termine le switch. Il ne termine pas à lui seul la boucle qui l’entoure. Un schéma clair consiste à affecter false à un indicateur de boucle dans le cas de sortie, puis à utiliser break pour quitter le switch. La boucle se termine lorsque la vérification suivante de sa condition constate que l’indicateur est faux. Les cas avec flèche n’ont pas besoin de break pour empêcher l’enchaînement des cas.

Un break sans étiquette est autorisé dans une boucle ou un switch ; continue est autorisé dans une boucle. Les placer ailleurs provoque une erreur de compilation. Garde la règle d’arrêt normale dans la condition de la boucle lorsqu’elle peut s’y trouver. Utilise while (true) avec un break lorsque le test d’arrêt se place naturellement après la lecture d’une saisie mais avant son traitement. Plusieurs sorties peuvent être utiles, mais chaque chemin supplémentaire ajoute des états à suivre lors du suivi de l’exécution.

Un compteur enregistre le nombre de valeurs qui répondent à une condition. Un accumulateur combine des valeurs dans un résultat cumulé. Déclare les deux avant la boucle pour que chaque passage poursuive le travail précédent.

Initialise selon l’opération

Utilise int count = 0; et incrémente le compteur lorsqu’un élément répond à la condition. Une somme commence à 0 et utilise sum += value;. Un produit commence à 1, car multiplier un 0 initial effacerait l’effet de tous les facteurs suivants. Initialiser une somme dans le corps la remet à zéro à chaque passage.

Pour un intervalle, le pas de la boucle peut sélectionner les valeurs : additionner les entiers pairs de 2 à 100 par pas de 2 donne 2 550. Tu peux aussi placer une condition dans la boucle. Compter les nombres de 1 à 100 divisibles par 3 ou par 5 donne 47 : les six multiples de 15 ne doivent être comptés qu’une seule fois.

Arrête la saisie avant d’ajouter la valeur

Une sentinelle est une valeur de saisie spéciale qui met fin à la lecture. Ce n’est pas une valeur ordinaire des données :

int sum = 0;
int count = 0;
while (true) {
    int number = Integer.valueOf(scanner.nextLine());
    if (number == 0) {
        break;
    }
    sum += number;
    count++;
}

Pour la saisie 12, 7, 5, 0, la somme prend successivement les valeurs 12, 19 et 24. Le compteur atteint 3. Le 0 final déclenche le break avant que l’une ou l’autre variable change. Le compter créerait un quatrième élément et donnerait une moyenne incorrecte, même si l’ajout de zéro ne change pas la somme.

Divise seulement après avoir vérifié le compteur

if (count > 0) {
    double average = (double) sum / count;
    System.out.println(average);
} else {
    System.out.println("No numbers entered");
}

L’exemple affiche 8.0. Avec des opérandes entiers, la division supprime la partie fractionnaire : 25 / 4 vaut 6. Convertis avant de diviser pour obtenir 6,25 : (double) sum / count. Effectuer le transtypage après, (double) (sum / count), ne fait que convertir le résultat déjà tronqué en 6,0.

Si la sentinelle arrive en premier, le compteur vaut 0. Une division entière par zéro lève une ArithmeticException ; une somme en virgule flottante égale à zéro divisée par zéro donne NaN. La vérification du compteur évite qu’une saisie vide produise une moyenne qui n’a pas de sens.

Suis plusieurs résultats en un passage

Pour les scores 55, 72, 90, 48 et 81, avec un seuil de réussite de 60, on obtient cinq scores et trois réussites. Garde un compteur total pour chaque score et un compteur de réussites dans la condition de réussite. 100.0 * passed / total donne 60,0 pour cent ; 100.0 fait utiliser des calculs en virgule flottante. Vérifie aussi que le total est positif avant cette division.

L’endroit où se fait l’affichage change ce qui est montré. Des distances de 5, 3 et 8 km donnent des sommes cumulées de 5, 8 et 16 km lorsqu’elles sont affichées dans la boucle après l’addition. Un affichage après la boucle ne donne que le résultat final, 16 km.

Choisis un type assez grand pour la somme

Le maximum d’un int est 2 147 483 647. La somme de tous les entiers de 1 à 100 000 devrait donner 5 000 050 000, mais un int revient à 705 082 704 sans signaler d’erreur. long sum = 0; contient correctement cette somme ; le maximum d’un long est d’environ 9,2 × 10¹⁸. Une conversion élargissante effectuée après le dépassement de capacité ne peut pas restaurer la valeur perdue.

Certaines boucles mémorisent une meilleure valeur ; d’autres mémorisent si une correspondance a été trouvée. Choisis l’état initial pour qu’il reflète la situation réelle avant et après chaque passage.

Garde la meilleure valeur rencontrée jusque-là

Pour suivre un maximum, remplace-le uniquement lorsque la valeur actuelle est plus grande : if (value > max) { max = value; }. En partant de la première mesure, les températures 14, 19, 11, 23 et 17 °C donnent les maximums successifs 14, 19, 19, 23 et 23 °C. Un minimum utilise < à la place.

Initialiser un maximum à 0 échoue avec des données toutes négatives : -5, -2 et -9 laisseraient à tort 0 comme résultat. Initialise-le à partir d’une mesure réelle ou commence à Integer.MIN_VALUE pour un maximum de type int et à Integer.MAX_VALUE pour un minimum de type int. Indique l’absence de résultat lorsqu’il n’y a eu aucune mesure.

Pour enregistrer une position, mets-la à jour dans la même branche que la valeur. Un > strict conserve le premier maximum en cas d’égalité ; >= le remplace à nouveau et conserve le dernier.

Arrête-toi après avoir trouvé une correspondance

int n = 1;
while (n * n <= 500) {
    n++;
}

À 22, le carré est 484, donc un autre passage s’exécute. À 23, il est 529 et la condition n’est plus satisfaite. La boucle a trouvé le plus petit entier positif dont le carré dépasse 500. Une recherche bornée peut à la place tester chaque candidat dans une boucle for et s’arrêter avec break à la première correspondance.

Pour une question portant sur au moins une valeur, initialise un indicateur à faux et passe-le à vrai lorsqu’une correspondance est trouvée. Pour une question portant sur toutes les valeurs, initialise-le à vrai et passe-le à faux dès qu’un contre-exemple apparaît. Ne réinitialise aucun de ces indicateurs dans une branche else pour les valeurs suivantes : par exemple, une mesure ultérieure qui ne correspond pas n’efface pas une mesure négative antérieure.

Teste la présence d’un diviseur

Un nombre premier est supérieur ou égal à 2 et ne possède aucun diviseur de 2 jusqu’au nombre qui le précède. Pour un petit entier positif, une vérification plus courte teste les diviseurs seulement jusqu’à sa racine carrée :

int n = 91;
boolean isPrime = n >= 2;
for (int d = 2; d * d <= n; d++) {
    if (n % d == 0) {
        isPrime = false;
        break;
    }
}

Les deux facteurs d’une paire ne peuvent pas être tous deux supérieurs à la racine carrée. Pour 91, le diviseur 7 donne un reste nul et fait passer l’indicateur à faux. Pour 97, aucun diviseur de 2 à 9 ne le divise, donc l’indicateur reste vrai. Les valeurs inférieures à 2 commencent avec un indicateur faux. Pour les grands entiers positifs de type int, utilise d <= n / d pour éviter un dépassement de capacité dans d * d.

Retire un chiffre décimal par passage

Pour un entier positif ou nul, % 10 extrait le dernier chiffre et la division entière / 10 le retire :

int n = 4072;
int sum = 0;
while (n > 0) {
    sum += n % 10;
    n /= 10;
}

Les chiffres sont 2, 7, 0 et 4, ce qui donne 13. La variable de travail n finit à 0. Pour inverser les chiffres, mets à jour reversed = reversed * 10 + n % 10; avant de retirer le chiffre ; 1 234 devient 4 321 lorsque le résultat tient dans le type choisi.

Pour compter les chiffres, zéro nécessite un passage même si n > 0 est faux au départ. Utilise une boucle do-while qui incrémente le compteur et divise n par 10. Elle compte un chiffre pour 0 et le nombre habituel pour les valeurs positives.

Les boucles imbriquées répètent une répétition complète à chaque passage externe. Elles sont utiles pour les lignes, les colonnes, les tableaux et les formes. La boucle interne doit repartir de zéro chaque fois que la boucle externe l’atteint.

Affiche une ligne, puis termine-la

for (int row = 1; row <= 3; row++) {
    for (int col = 1; col <= 5; col++) {
        System.out.print(row * col + "\t");
    }
    System.out.println();
}

La première ligne contient 1, 2, 3, 4, 5 ; la deuxième contient 2, 4, 6, 8, 10 ; la troisième contient 3, 6, 9, 12, 15. Le print interne crée des colonnes sur une ligne ; le println après la boucle interne termine cette ligne. Déplacer println dans la boucle interne place chaque produit sur sa propre ligne.

Lorsque les nombres de passages sont fixes, multiplie les passages externes par les passages internes. Trois passages externes et quatre passages internes exécutent le corps interne 12 fois. Le tableau ci-dessus comporte trois fois cinq affichages de produits, soit 15.

Fais varier la taille des lignes

for (int row = 1; row <= 4; row++) {
    for (int col = 1; col <= row; col++) {
        System.out.print("*");
    }
    System.out.println();
}

La borne interne dépend maintenant de la ligne. Les nombres de passages sont 1, 2, 3 et 4, donc le triangle contient 10 étoiles. Une seule multiplication de nombres de passages fixes serait incorrecte, car la boucle interne ne s’exécute pas autant de fois sur chaque ligne.

Utilise des noms différents pour les compteurs de boucles dont les portées se chevauchent. Déclarer un autre int i dans une boucle où i est déjà accessible provoque une erreur de compilation. Pour une boucle while interne, initialise son compteur au début de chaque passage externe. L’initialiser uniquement avant la boucle externe le laisse au-delà de la borne après la première ligne.

Suis les valeurs au même moment

Pour une boucle de 1 à 4, soustrais les valeurs impaires d’une somme initialisée à 0 et ajoute les valeurs paires :

Indique si une ligne décrit le début ou la fin d’un passage. Inclus le test final qui échoue lorsque tu vérifies la fin de la boucle. Un suivi qui mélange des valeurs avant et après mise à jour peut faire paraître incorrecte une boucle correcte.

Place des séparateurs entre les éléments

Cinq nombres nécessitent quatre virgules. Affiche un séparateur avant chaque élément sauf le premier :

for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        System.out.print(", ");
    }
    System.out.print(i);
}

La sortie est « 1, 2, 3, 4, 5 », sans virgule au début ni à la fin. C’est un problème des piquets : le nombre d’espaces entre les éléments diffère du nombre d’éléments.

Teste des cas qui révèlent les erreurs

Essaie zéro passage, un passage et les valeurs situées sur chaque borne et juste à côté. Pour les boucles de saisie, essaie d’abord la sentinelle. Pour les boucles imbriquées, vérifie si la deuxième ligne est correctement réinitialisée. Des affichages temporaires des variables de boucle révèlent la progression réelle. Si un programme reste bloqué, examine chaque chemin à la recherche d’une mise à jour ou d’une sortie et arrête-le avec Ctrl+C dans un terminal ou avec le bouton d’arrêt de l’environnement de développement.