Arrondi et mise en forme des nombres

1. Introduction

Dans la vie courante, nous n’avons que rarement besoin d’afficher de longues suites de décimales. Par exemple, lorsque vous calculez le prix d’un article, un salaire, une moyenne ou la surface d’une pièce — deux décimales suffisent généralement, pas 15.

Par exemple, le résultat d’une division :

double x = 10.0 / 3.0;
System.out.println(x); // 3.3333333333333335

Un utilisateur, en voyant un tel résultat, peut s’inquiéter et croire que le programme dysfonctionne. C’est pourquoi il faut souvent arrondir les nombres — à l’entier le plus proche, à deux décimales, etc.

En Java, il existe plusieurs outils pratiques pour cela.

2. Méthode Math.round() : arrondir à l’entier le plus proche

Le moyen le plus simple d’arrondir un nombre est d’utiliser la méthode Math.round(). Elle prend un nombre à virgule flottante (soit un float, soit un double) et renvoie l’entier le plus proche.

Comment fonctionne Math.round

• Si la partie fractionnaire est inférieure à 0.5 — on arrondit vers le bas.
• Si la partie fractionnaire est 0.5 ou plus — on arrondit vers le haut.

Exemples :

System.out.println(Math.round(2.3)); // 2
System.out.println(Math.round(2.7)); // 3
System.out.println(Math.round(2.5)); // 3
System.out.println(Math.round(-2.5)); // -2

Type de valeur de retour

• Si vous passez un float, il renverra un int.
• Si vous passez un double, il renverra un long.

float f = 5.8f;
int roundedF = Math.round(f); // 6

double d = 5.8;
long roundedD = Math.round(d); // 6

Remarque : cela surprend parfois — on arrondit un double, et on obtient un long ! Si vous avez besoin d’un int, il faudra faire un transtypage explicite :

int rounded = (int) Math.round(5.6); // 6

3. Arrondir à un nombre de décimales donné

Il faut souvent arrondir non pas à l’entier, mais par exemple à deux décimales (pour l’argent, les pourcentages, etc.).

En Java, il n’existe pas de méthode « magique » du type Math.roundTo2Digits(), mais on peut le faire manuellement.

Méthode 1 : astuce mathématique avec multiplication et division

1. Multiplier le nombre par 100 (si vous voulez deux décimales).
2. Arrondir à l’entier avec Math.round.
3. Diviser de nouveau par 100.

Exemple :

double value = 3.14159;
double rounded = Math.round(value * 100.0) / 100.0;
System.out.println(rounded); // 3.14

Comment ça marche :

• 3.14159 * 100 = 314.159
• Math.round(314.159) = 314
• 314 / 100.0 = 3.14

4. Mise en forme des nombres : classe DecimalFormat

Parfois, il ne suffit pas d’arrondir un nombre, il faut aussi l’afficher joliment — avec un nombre précis de décimales, des zéros en tête, des séparateurs de milliers, etc. Pour cela, Java propose la classe DecimalFormat du package java.text.

Comment fonctionne DecimalFormat

1. Créer un objet avec le modèle voulu.
2. Appeler sa méthode format(...).

import java.text.DecimalFormat;

double value = 3.14159;

DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(value)); // 3.14

Comment fonctionne le modèle

• "0.00" — toujours deux décimales (même si le nombre est entier).
• "0.###" — jusqu’à trois décimales, les zéros superflus ne sont pas affichés.
• "#,##0.00" — ajoute des séparateurs de milliers (par exemple, "1,234.56").

Exemples de différents modèles :

"0.00"

"0.00"

"0.00"

"0.###"

"0.###"

"#,##0.00"

Exemple avec séparateurs de milliers

DecimalFormat df = new DecimalFormat("#,##0.00");
System.out.println(df.format(1234567.89)); // 1,234,567.89

Exemple : affichage sans zéros superflus

DecimalFormat df = new DecimalFormat("0.##");
System.out.println(df.format(3.1));   // 3.1
System.out.println(df.format(3.141)); // 3.14
System.out.println(df.format(3.145)); // 3.15

5. Mise en forme avec String.format

Pour des cas simples, il est parfois pratique d’utiliser String.format — une façon intégrée de formater des chaînes, similaire à printf dans d’autres langages.

double value = 3.14159;
System.out.println(String.format("%.2f", value)); // 3.14

Ici "%.2f" — signifie « afficher un nombre avec deux décimales ».

Comparaison des approches :

• DecimalFormat — plus puissant, prend en charge les modèles et la localisation, pratique pour les séparateurs de milliers.
• String.format — plus simple si vous souhaitez seulement fixer le nombre de décimales.

6. Particularités de l’arrondi : Math.floor, Math.ceil, Math.rint

• Math.floor(x) — arrondit vers le bas (vers l’inférieur), y compris pour les nombres négatifs.
• Math.ceil(x) — arrondit vers le haut (vers le supérieur).
• Math.rint(x) — arrondit à l’entier le plus proche, mais renvoie un double.

Exemples :

System.out.println(Math.floor(2.7)); // 2.0
System.out.println(Math.ceil(2.1));  // 3.0
System.out.println(Math.rint(2.5));  // 2.0 (oui, oui, ce n'est pas une faute de frappe!)
System.out.println(Math.rint(3.5));  // 4.0

Attention : Math.rint arrondit parfois « à l’entier pair le plus proche » — cette règle (appelée « arrondi bancaire ») aide à réduire l’accumulation d’erreurs lors de calculs massifs.

7. Quelques subtilités utiles

Visualisation : tableau des arrondis

L’arrondi n’est pas la mise en forme !

Il est très important de comprendre la différence entre l’arrondi et la mise en forme.

• Arrondi — modification de la valeur du nombre (par exemple, 2.718 → 2.72).
• Mise en forme — modification de l’apparence à l’affichage (par exemple, 2.718 → "2.72" à l’écran, mais en mémoire il reste 2.718).

double x = 2.718;
System.out.println(String.format("%.2f", x)); // 2.72
System.out.println(x); // 2.718

Si vous voulez réutiliser le nombre arrondi dans des calculs ultérieurs — arrondissez mathématiquement ! S’il s’agit seulement d’affichage — formatez.

8. Erreurs courantes lors de l’arrondi et de la mise en forme des nombres

Erreur n° 1 : vous n’avez arrondi que pour l’affichage, puis vous utilisez encore le nombre « à rallonge ».
Situation très fréquente — afficher une valeur joliment formatée à l’écran, puis utiliser le nombre « long » d’origine dans les calculs. Pour l’argent, les notes et les totaux — arrondissez d’abord (par exemple, avec Math.round ou l’astuce de multiplication/division), puis enregistrez/transmettez la valeur à l’utilisateur.

Erreur n° 2 : s’attendre à ce que Math.round(x) renvoie un double avec deux décimales.
Math.round() arrondit toujours à l’entier le plus proche : pour un float il renvoie un int, pour un double — un long. Pour deux décimales, utilisez la multiplication/division ou la mise en forme.

Erreur n° 3 : utiliser DecimalFormat pour des calculs.
DecimalFormat.format() renvoie une chaîne. On ne peut pas l’utiliser en arithmétique : vous obtiendrez une erreur de compilation ou une NumberFormatException en cas d’analyse inverse.

Erreur n° 4 : mauvais modèle DecimalFormat.
Le modèle doit correspondre à vos attentes : "0.00" affichera toujours deux décimales ("2.00"), tandis que "0.##" supprimera les zéros superflus ("2", "2.1", "2.12").

Erreur n° 5 : perte de précision lors d’une division par 100.
Si vous divisez un int par un int, le résultat est aussi un int !

int a = 5;
System.out.println(a / 2); // 2, et non 2,5!

Pour obtenir une division en nombres réels, au moins un des opérandes doit être de type double :

int a = 5;
System.out.println(a / 2.0); // 2.5