Arrondir les nombres en Java

Les nombres à virgule flottante (float, double) sont utilisés lors du calcul d'expressions nécessitant une précision décimale. Une grande précision est souvent nécessaire dans la comptabilité et d’autres opérations informatiques. Mais avons-nous toujours besoin d’une longue « queue » de chiffres après la virgule ? Peut-être qu'une précision de trois parties réelles nous suffit ? Et nous sommes satisfaits de cette option, comment bien effectuer l'arrondi ? C'est exactement ce dont nous allons parler aujourd'hui : nous examinerons les moyens d'arrondir les nombres en Java .

Format de chaîne

Comme première méthode, nous examinerons l'arrondi au double :

double value = 34.766674;
String result = String.format("%.3f",value);
System.out.print(result);//  34,767

En conséquence, nous formaterons notre nombre à virgule flottante 34766674 avec une précision de 3 décimales , puisque dans les instructions de formatage nous avons spécifié trois décimales "%.3f. À son tour, %f lors du formatage d'une chaîne indique le type de virgule flottante nombres, qui inclut les types de données double et float en Java. Dans l'exemple ci-dessus, nous affichons la valeur résultante sur la console. Maintenant, la question est : comment pourrions-nous raccourcir cela ? C'est simple : vous devez utiliser printf, qui à son tour est format + print. Par conséquent, notre exemple précédent se réduirait à :

double value = 34.766674;
System.out.printf("%.3f",value);

En plus de cette méthode , l'instance out de la classe PrintStream possède également une méthode format, qui fonctionne de la même manière :

double value = 34.766674;
System.out.format("%.3f",value);

L'arrondi s'effectue en mode HALF_UP - vers le nombre le plus proche de celui à couper (à 0 ou 10). Si ces nombres sont équidistants (dans le cas de 5), alors un arrondi est effectué. Exemple:

String firstResult = String.format("%.3f",7.0004);// 7,000
String secondResult = String.format("%.3f",7.0005);// 7,001
String thirdResult = String.format("%.3f",7.0006);// 7,001

Nous discuterons des modes d’arrondi plus en détail ci-dessous.

Format décimal

Une autre option consiste à utiliser la classe DecimalFormat . Il est conçu pour formater n'importe quel nombre en Java, qu'il s'agisse d'un nombre entier ou d'un nombre à virgule flottante. Lorsque nous instancions DecimalFormat, nous pouvons lui transmettre une chaîne de format. Il indiquera le nombre de décimales à formater pour l'entrée. Voici à quoi ressemblerait notre exemple en utilisant DecimalFormat :

double value = 34.766674;
DecimalFormat decimalFormat = new DecimalFormat( "#.###" );
String result = decimalFormat.format(value);
System.out.print(result);//34,767

La ligne #.### est un modèle qui indique que nous formatons la valeur transmise à 3 décimales. Pour modifier le modèle après la création de l'objet DecimalFormat, vous pouvez utiliser ses méthodes applyPattern et applyLocalizedPattern :

DecimalFormat decimalFormat = new DecimalFormat("#.###");
decimalFormat.applyPattern("#.#");
decimalFormat.applyLocalizedPattern("#.#####");

Mais aujourd’hui, nous parlons d’arrondi, n’est-ce pas ? Lors de la troncature d'un nombre avec des décimales au-delà du modèle spécifié, DecimalFormat arrondit le nombre si le dernier nombre tronqué est supérieur à 5. Mais que se passe-t-il si le nombre est 5 ? Il s’avère que c’est exactement au milieu entre les nombres entiers les plus proches. Et alors ? Dans ce cas, le numéro précédent est pris en compte. S'il est pair, on arrondit :

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4565);
System.out.println((result));// 7,457

Si impair, il n'est pas effectué :

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4575);
System.out.println((result));// 7,457

Il existe une légère différence entre le formatage des nombres à virgule flottante à l'aide de String.format() et DecimalFormat.format(). Le premier imprimera toujours les zéros à droite même s’il n’y a pas de partie fractionnaire. Par exemple:

String firstResult = String.format("%.3f", 7.000132);
System.out.println((firstResult)); // 7.000

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String secondResult = decimalFormat.format(7.000132);
System.out.println((secondResult));  // 7

Comme nous pouvons le voir, lors du formatage du nombre 7,000132 à trois décimales, la méthode format() de String affichera 7,000, tandis que la méthode format() de DecimalFormat affichera 7. Autrement dit, vous pouvez choisir String.format() ou DecimalFormat.format( ) selon que vous avez besoin ou non de zéros à droite. En utilisant les méthodes décrites ci-dessus, nous avons reçu le résultat sous la forme d'une chaîne. Voyons comment récupérer exactement les valeurs numériques.

Mathématiques

Il est impossible de ne pas mentionner une classe spéciale conçue pour diverses opérations arithmétiques avec des nombres - Math . Cette classe dispose également de méthodes d'arrondi, mais contrairement à celles déjà décrites, elles ne permettent pas de fixer un certain nombre de décimales, mais plutôt d'arrondir à un nombre entier :

• Math.ceil() arrondit à l'entier le plus proche, mais renvoie non pas un type entier, mais un double :

  double value = 34.777774;
  double result = Math.ceil(value);
  System.out.println((result)); //35.0

  Même si nous avons 34,0000000, après avoir utilisé Math.ceil , nous obtiendrons toujours 35,0.

  Math.floor() arrondit à l'entier le plus proche, renvoyant également le résultat sous forme double :

  double value = 34.777774;
  double result = Math.floor(value);
  System.out.println((result)); //34.0

  Encore une fois, même si nous avons une valeur de 34,999999999, après avoir utilisé Math.floor , nous obtiendrons 34,0.

• Math.round () - arrondit à l'entier le plus proche, donnant le résultat int :

  double value = 34.777774;
  int result = Math.round(value);
  System.out.println((result)); //35

  Si notre nombre est 34,5, il est arrondi à 35, mais s'il est légèrement inférieur à 34,499, le nombre est tronqué à 34.

  Afin de ne pas simplement couper toute la partie réelle, mais de réguler ce processus à un certain nombre de décimales et en même temps d'arrondir, le nombre est multiplié par 10^n (10 à la puissance n), où n est égal au nombre de décimales nécessaires. Après cela, une méthode de la classe Math est utilisée pour arrondir, puis à nouveau divisée par 10 ^ n :

  double value = 34.777774;
  double scale = Math.pow(10, 3);
  double result = Math.ceil(value * scale) / scale;
  System.out.println((result)); //34.778

  Math.pow - prend deux arguments. Le premier est le nombre, le second est la puissance à laquelle il doit être élevé.

Arrondir avec BigDecimal

BigDecimal est une classe qui vous permet de travailler avec des nombres à virgule flottante. En particulier, sa principale caractéristique est qu'il peut stocker des nombres fractionnaires de longueur arbitraire (c'est-à-dire qu'il n'y a aucune limite sur la plage du nombre). De plus, cette classe stocke diverses méthodes de traitement arithmétique, notamment l'arrondi. La classe de cet objet peut être créée en définissant le constructeur sur double, string pour afficher un nombre à virgule flottante, double et MathContext , etc. MathContext est une combinaison de RoundingMode et d'un nombre qui décrit le nombre total de chiffres dans la valeur recherchée. Règles d'arrondi RoundingMode : DOWN - arrondi vers zéro. UP — arrondi à partir du mode zéro. PLAFOND - arrondi vers l'infini positif. SOL - arrondi vers l'infini négatif. HALF_UP - Arrondit au "voisin le plus proche" si les deux voisins ne sont pas équidistants (c'est-à-dire lorsque le nombre arrondi est 5). Dans ce cas, un arrondi est effectué. HALF_DOWN - arrondi vers le « voisin le plus proche ». Si les deux voisins ne sont pas équidistants, arrondissez dans ce cas à l’inférieur. HALF_EVEN - Arrondit au "voisin le plus proche" si les deux voisins ne sont pas équidistants. Dans ce cas, arrondissez au voisin pair (comme dans DecimalFormat décrit ci-dessus). INUTILE - Utilisé pour confirmer que l'opération demandée a le résultat correct. Il n’est donc pas nécessaire d’arrondir les chiffres. Exemple:

MathContext context = new MathContext(5, RoundingMode.HALF_UP);
double value = 34.777554;
BigDecimal result = new BigDecimal(value, context);
System.out.println(result); //34.778

En plus de la possibilité de définir une règle d'arrondi dans le constructeur, BigDecimal vous permet de définir le mode d'arrondi après la création de l'instance. Pour ce faire, utilisez la méthode setScale , dans laquelle vous devez définir le nombre de décimales et les règles d'arrondi :

double value = 34.777554;
BigDecimal result = new BigDecimal(value);
result = result.setScale(3, RoundingMode.DOWN);
System.out.println(result); //34.777

BigDecimal possède également des variables int internes conçues pour définir le mode d'arrondi ( ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR ...). Ce sont des règles d'arrondi similaires à celles présentées dans la classe RoundingMode et sont utilisées de la même manière dans setScale :

BigDecimal result = new BigDecimal(value);
result = result.setScale(3, BigDecimal.ROUND_DOWN);

En savoir plus sur la classe BigDecimal dans cet article .