Arrondir les nombres en Java : comment obtenir n décimales

Comment arrondir un nombre à N décimales en Java ? Analyse complète avec exemples

L'arrondi des nombres est l'une des tâches que chaque développeur Java rencontre, qu'il soit débutant affichant des prix dans la console ou ingénieur expérimenté travaillant avec des calculs financiers. Cela semble simple, non ? Mais en pratique, l'arrondi d'un double en Java cache de nombreux pièges : des erreurs de précision « magiques » au choix du bon outil pour une tâche spécifique.

Dans cet article, nous allons examiner toutes les méthodes principales pour arrondir un nombre en Java à un nombre donné de décimales. Vous découvrirez quand utiliser Math.round, pourquoi Double est dangereux dans les calculs financiers, et pourquoi BigDecimal est votre meilleur ami quand il s'agit d'argent. C'est parti !

Le problème : pourquoi un simple arrondi en Java n'est-il pas toujours simple ?

Avant de passer aux solutions, comprenons la racine du problème. Le type double en Java (comme dans la plupart des langages) stocke les nombres à virgule flottante au format binaire. De ce fait, de nombreuses fractions décimales (par exemple 0,1 ou 0,2) ne peuvent pas être représentées exactement. Essayez d'exécuter :

System.out.println(0.1 + 0.2); // Affiche 0.30000000000000004

Pour un affichage à l'écran, cela peut être acceptable, mais pour des calculs, c'est une catastrophe. Par conséquent, l'arrondi à 2 décimales en Java (ou à tout autre nombre) doit être effectué en connaissance de cause.

Méthode 1 : Arrondi mathématique avec Math.round

La méthode la plus directe consiste à utiliser Math.round(). Elle arrondit le nombre à l'entier le plus proche. Pour obtenir N décimales, on « décale » la virgule décimale, on arrondit, puis on décale en sens inverse.

Exemple : arrondir un double à 2 décimales :

public static double roundWithMathRound(double value, int places) {    double scale = Math.pow(10, places);    return Math.round(value * scale) / scale;}

// Utilisationdouble number = 3.14159265;double rounded = roundWithMathRound(number, 2);System.out.println(rounded); // 3.14

Avantages : Simplicité, aucune dépendance à des bibliothèques externes.
Inconvénients : Fonctionne avec double, donc toujours sujet aux erreurs de précision sur les valeurs limites. Ne convient pas pour la finance.

Méthode 2 : Formatage avec DecimalFormat

La classe DecimalFormat du package java.text permet non seulement d'arrondir, mais aussi de formater joliment un nombre en chaîne de caractères. C'est la solution idéale pour les interfaces utilisateur et les rapports.

import java.text.DecimalFormat;

public static String formatWithDecimalFormat(double value, int places) {    // Création du motif : #.00 pour deux décimales    StringBuilder pattern = new StringBuilder("#.");    for (int i = 0; i < places; i++) {        pattern.append("0");    }    DecimalFormat df = new DecimalFormat(pattern.toString());    return df.format(value);}

// UtilisationString result = formatWithDecimalFormat(2.71828, 3);System.out.println(result); // 2.718

Vous pouvez également configurer le mode d'arrondi (RoundingMode) :

df.setRoundingMode(RoundingMode.HALF_UP); // Arrondi mathématique standard

Important : DecimalFormat retourne une String, pas un nombre. Si vous avez besoin d'un double pour des calculs ultérieurs, cette méthode ne convient pas.

Méthode 3 : BigDecimal — l'étalon-or de la précision

Lorsque la précision est critique (finance, calculs scientifiques), BigDecimal entre en scène. Il permet de contrôler chaque chiffre et d'éviter les imprécisions du double.

import java.math.BigDecimal;import java.math.RoundingMode;

public static BigDecimal roundWithBigDecimal(double value, int places) {\