Comment arrondir un double à deux décimales en Java?

Travaillez-vous avec de l’argent? Créer une Ssortingng puis la reconvertir est assez complexe.

Utilisez BigDecimal . Cela a été discuté en profondeur. Vous devriez avoir une classe Money et le montant devrait être un BigDecimal .

Même si vous ne travaillez pas avec de l’argent, considérez BigDecimal .

Il suffit d’utiliser: (facile comme tarte)

 double number = 651.5176515121351; number = Math.round(number * 100); number = number/100; 

La sortie sera 651,52

Utilisez un espace réservé pour les chiffres ( 0 ), comme avec les zéros à la fin / précédant « # » affichés comme étant absents:

 DecimalFormat twoDForm = new DecimalFormat("#.00"); 

Vous ne pouvez pas arrondir un double à [un nombre quelconque de décimales], car les doubles n’ont pas de décimales. Vous pouvez convertir un double en une chaîne de base 10 avec N décimales, car la base 10 a bien des décimales, mais lorsque vous la reconvertissez, vous êtes de nouveau en double, avec des décimales binarys .

C’est le plus simple que je puisse faire, mais le travail est beaucoup plus facile que la plupart des exemples que j’ai vus.

  double total = 1.4563; total = Math.round(total * 100); System.out.println(total / 100); 

Le résultat est 1,46.

Utilisez ceci

Ssortingng.format (“%. 2f”, doubleValue) // change 2, selon vos besoins.

Vous pouvez utiliser org.apache.commons.math.util.MathUtils à partir de Apache Common

double round = MathUtils.round(double1, 2, BigDecimal.ROUND_HALF_DOWN);

Vous pouvez utiliser Apache Commons Math:

 Precision.round(double x, int scale) 

source: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html#round(double,%20int)

Votre classe Money pourrait être représentée comme une sous-classe de Long ou avoir un membre représentant la valeur monétaire en tant que longueur native. Ensuite, lors de l’atsortingbution de valeurs à vos instanciations d’argent, vous stockerez toujours des valeurs qui sont en réalité des valeurs REAL Money. Vous produisez simplement votre object Money (via la méthode toSsortingng () remplacée par votre Money) avec la mise en forme appropriée. Par exemple, 1,25 $ dans la représentation interne d’un object Money est égal à 125. Vous représentez l’argent sous forme de centime ou de pence ou quelle que soit la dénomination minimale dans la devise avec laquelle vous scellez … Non, vous ne pouvez JAMAIS stocker une valeur monétaire «illégale», par exemple 1,257 $.

montant double = 25,00;

NumberFormat formatter = new DecimalFormat (“# 0.00”);

System.out.println (formatter.format (amount));

 DecimalFormat df = new DecimalFormat("###.##"); double total = Double.valueOf(val); 

Si vous voulez le résultat à deux décimales, vous pouvez le faire

 // assuming you want to round to Infinity. double tip = (long) (amount * percent + 0.5) / 100.0; 

Ce résultat n’est pas précis, mais Double.toSsortingng (double) corrigera pour cela et imprimera une à deux décimales. Cependant, dès que vous effectuez un autre calcul, vous pouvez obtenir un résultat qui ne sera pas implicitement arrondi. 😉

Math.round est une réponse,

 public class Util { public static Double formatDouble(Double valueToFormat) { long rounded = Math.round(valueToFormat*100); return rounded/100.0; } } 

Test à Spock, Groovy

 void "test double format"(){ given: Double performance = 0.6666666666666666 when: Double formattedPerformance = Util.formatDouble(performance) println "######################## formatted ######################### => ${formattedPerformance}" then: 0.67 == formattedPerformance } 

En supposant que la quantité peut être positive ou négative, arrondir à deux décimales peut utiliser le fragment de code suivant.

 amount = roundTwoDecimals(amount); public double roundTwoDecimals(double d) { if (d < 0) d -= 0.005; else if (d > 0) d += 0.005; return (double)((long)(d * 100.0))/100); } 

À partir de java 1.8, vous pouvez faire plus avec les expressions lambda et vérifier les null. En outre, l’un peut gérer Float ou Double et un nombre variable de points décimaux (y compris 2 :-)).

 public static Double round(Number src, int decimalPlaces) { return Optional.ofNullable(src) .map(Number::doubleValue) .map(BigDecimal::new) .map(dbl -> dbl.setScale(decimalPlaces, BigDecimal.ROUND_HALF_UP)) .map(BigDecimal::doubleValue) .orElse(null); } 

où num est le nombre double

• Entier 2 indique le nombre de décimales à imprimer.

• Ici, nous prenons 2 paliers décimaux

  System.out.printf (“%. 2f”, num);

Vous pouvez essayer celui-ci:

 public static Ssortingng getRoundedValue(Double value, Ssortingng format) { DecimalFormat df; if(format == null) df = new DecimalFormat("#.00"); else df = new DecimalFormat(format); return df.format(value); } 

ou

 public static double roundDoubleValue(double value, int places) { if (places < 0) throw new IllegalArgumentException(); long factor = (long) Math.pow(10, places); value = value * factor; long tmp = Math.round(value); return (double) tmp / factor; } 

Voici un moyen simple de garantir la sortie du myFixedNumber arrondi à deux décimales:

 import java.text.DecimalFormat; public class TwoDecimalPlaces { static double myFixedNumber = 98765.4321; public static void main(Ssortingng[] args) { System.out.println(new DecimalFormat("0.00").format(myFixedNumber)); } } 

Le résultat est de: 98765.43

  int i = 180; int j = 1; double div= ((double)(j*100)/i); DecimalFormat df = new DecimalFormat("#.00"); // simple way to format till any deciaml points System.out.println(div); System.out.println(df.format(div)); 

Déclarez d’abord un object de la classe DecimalFormat . Notez que l’argument à l’intérieur du DecimalFormat est #.00 ce qui signifie exactement 2 décimales d’arrondi.

 private static DecimalFormat df2 = new DecimalFormat("#.00"); 

Maintenant, appliquez le format à votre valeur double:

 double input = 32.123456; System.out.println("double : " + df2.format(input)); // Output: 32.12 

Remarque en cas de double input = 32.1;

La sortie serait alors 32.10 et ainsi de suite.