Comment puis-je tronquer un double à deux décimales seulement en Java?

Par exemple, j’ai la variable 3.545555555, que je voudrais tronquer à seulement 3,54.

Si vous voulez que pour l’affichage, utilisez java.text.DecimalFormat :

  new DecimalFormat("#.##").format(dblVar); 

Si vous en avez besoin pour les calculs, utilisez java.lang.Math :

  Math.floor(value * 100) / 100; 
 DecimalFormat df = new DecimalFormat(fmt); df.setRoundingMode(RoundingMode.DOWN); s = df.format(d); 

Vérifiez les options RoundingMode et DecimalFormat disponibles.

Bit Old Forum, Aucune des réponses ci-dessus n’a fonctionné pour les valeurs positives et négatives (je veux dire pour le calcul et juste pour faire tronquer sans arrondi). A partir du nombre de décimales dans le lien Java

 private static BigDecimal truncateDecimal(double x,int numberofDecimals) { if ( x > 0) { return new BigDecimal(Ssortingng.valueOf(x)).setScale(numberofDecimals, BigDecimal.ROUND_FLOOR); } else { return new BigDecimal(Ssortingng.valueOf(x)).setScale(numberofDecimals, BigDecimal.ROUND_CEILING); } } 

Cette méthode a bien fonctionné pour moi.

 System.out.println(truncateDecimal(0, 2)); System.out.println(truncateDecimal(9.62, 2)); System.out.println(truncateDecimal(9.621, 2)); System.out.println(truncateDecimal(9.629, 2)); System.out.println(truncateDecimal(9.625, 2)); System.out.println(truncateDecimal(9.999, 2)); System.out.println(truncateDecimal(-9.999, 2)); System.out.println(truncateDecimal(-9.0, 2)); 

Résultats :

 0.00 9.62 9.62 9.62 9.62 9.99 -9.99 -9.00 

Notez d’abord qu’un double est une fraction binary et n’a pas vraiment de décimales.

Si vous avez besoin de décimales, utilisez un BigDecimal , qui possède une méthode setScale() pour la troncature, ou utilisez DecimalFormat pour obtenir une Ssortingng .

Si, pour une raison quelconque, vous ne souhaitez pas utiliser un BigDecimal vous pouvez convertir votre double en int pour le tronquer.

Si vous voulez tronquer à la place Ones :

  • simplement lancer à l’ int

Au dixième lieu:

  • multiplier par dix
  • lancer à l’ int
  • repasser au double
  • et diviser par dix.

Hundreths place

  • multiplier et diviser par 100 etc.

Exemple:

 static double truncateTo( double unroundedNumber, int decimalPlaces ){ int truncatedNumberInt = (int)( unroundedNumber * Math.pow( 10, decimalPlaces ) ); double truncatedNumber = (double)( truncatedNumberInt / Math.pow( 10, decimalPlaces ) ); return truncatedNumber; } 

Dans cet exemple, decimalPlaces correspondrait au nombre de places que vous voulez passer à PAST, donc 1 arrondirait à la dixième place, 2 au centième , etc. des dizaines, etc.)

Peut-être Math.floor(value * 100) / 100 ? Attention, les valeurs comme 3.54 peuvent ne pas être exactement représentées avec un double .

Vous pouvez utiliser l’object Class NumberFormat pour accomplir la tâche.

 // Creating number format object to set 2 places after decimal point NumberFormat nf = NumberFormat.getInstance(); nf.setMaximumFractionDigits(2); nf.setGroupingUsed(false); System.out.println(nf.format(precision));// Assuming precision is a double type variable 

3.545555555 pour obtenir 3,54. Essayez de suivre ceci:

  DecimalFormat df = new DecimalFormat("#.##"); df.setRoundingMode(RoundingMode.FLOOR); double result = new Double(df.format(3.545555555); 

Cela donnera = 3,54!

Je pense que le formatage en chaîne et la conversion en double vous donneront le résultat souhaité.

La valeur double ne sera pas round (), floor () ou ceil ().

Une solution rapide pourrait être:

  Ssortingng sValue = (Ssortingng) Ssortingng.format("%.2f", oldValue); Double newValue = Double.parseDouble(sValue); 

Vous pouvez utiliser la sValue à des fins d’affichage ou la nouvelle valeur pour le calcul.

Voici la méthode que j’utilise:

 double a=3.545555555; // just assigning your decimal to a variable a=a*100; // this sets a to 354.555555 a=Math.floor(a); // this sets a to 354 a=a/100; // this sets a to 3.54 and thus removing all your 5's 

Cela peut aussi être fait:

 a=Math.floor(a*100) / 100; 

Peut-être suite à:

 double roundTwoDecimals(double d) { DecimalFormat twoDForm = new DecimalFormat("#.##"); return Double.valueOf(twoDForm.format(d)); } 

Une vérification rapide consiste à utiliser la méthode Math.floor. J’ai créé une méthode pour vérifier un double pour deux décimales ou moins:

 public boolean checkTwoDecimalPlaces(double valueToCheck) { // Get two decimal value of input valueToCheck double twoDecimalValue = Math.floor(valueToCheck * 100) / 100; // Return true if the twoDecimalValue is the same as valueToCheck else return false return twoDecimalValue == valueToCheck; } 
 //if double_v is 3.545555555 Ssortingng ssortingng_v= Ssortingng.valueOf(double_v); int pointer_pos = average.indexOf('.');//we find the position of '.' ssortingng_v.subssortingng(0, pointer_pos+2));// in this way we get the double with only 2 decimal in ssortingng form double_v = Double.valueOf(ssortingng_v);//well this is the final result 

Eh bien, cela pourrait être un peu gênant, mais je pense que cela peut résoudre votre problème 🙂

J’ai une version légèrement modifiée de Mani .

 private static BigDecimal truncateDecimal(final double x, final int numberofDecimals) { return new BigDecimal(Ssortingng.valueOf(x)).setScale(numberofDecimals, BigDecimal.ROUND_DOWN); } public static void main(Ssortingng[] args) { System.out.println(truncateDecimal(0, 2)); System.out.println(truncateDecimal(9.62, 2)); System.out.println(truncateDecimal(9.621, 2)); System.out.println(truncateDecimal(9.629, 2)); System.out.println(truncateDecimal(9.625, 2)); System.out.println(truncateDecimal(9.999, 2)); System.out.println(truncateDecimal(3.545555555, 2)); System.out.println(truncateDecimal(9.0, 2)); System.out.println(truncateDecimal(-9.62, 2)); System.out.println(truncateDecimal(-9.621, 2)); System.out.println(truncateDecimal(-9.629, 2)); System.out.println(truncateDecimal(-9.625, 2)); System.out.println(truncateDecimal(-9.999, 2)); System.out.println(truncateDecimal(-9.0, 2)); System.out.println(truncateDecimal(-3.545555555, 2)); } 

Sortie:

 0.00 9.62 9.62 9.62 9.62 9.99 9.00 3.54 -9.62 -9.62 -9.62 -9.62 -9.99 -9.00 -3.54 

Cela a fonctionné pour moi:

 double input = 104.8695412 //For example long roundedInt = Math.round(input * 100); double result = (double) roundedInt/100; //result == 104.87 

Personnellement, j’aime cette version car elle effectue l’arrondi numériquement plutôt que de le convertir en Ssortingng (ou similaire) et de le formater ensuite.