Comment arrondir un nombre à n décimales dans Java
Ce que je voudrais, c’est une méthode pour convertir un double en chaîne qui arrondit à l’aide de la méthode de demi-utilisation - c’est-à-dire que si la décimale à arrondir est 5, elle arrondit toujours au nombre précédent. C'est la méthode standard d'arrondi attendue par la plupart des gens dans la plupart des situations.
Je souhaite également que seuls les chiffres significatifs soient affichés - c’est-à-dire qu’il ne devrait pas y avoir de zéros à la fin.
Je sais qu'une méthode pour ce faire consiste à utiliser la méthode String.format:
String.format("%.5g%n", 0.912385);
résultats:
0.91239
ce qui est excellent, mais il affiche toujours des nombres avec 5 décimales, même s’ils ne sont pas significatifs:
String.format("%.5g%n", 0.912300);
résultats:
0.91230
Une autre méthode consiste à utiliser le DecimalFormatter:
DecimalFormat df = new DecimalFormat("#.#####");
df.format(0.912385);
résultats:
0.91238
Cependant, comme vous pouvez le constater, cette méthode est arrondie à moitié. C'est-à-dire qu'il sera arrondi si le chiffre précédent est pair. Ce que j'aimerais, c'est ceci:
0.912385 -> 0.91239
0.912300 -> 0.9123
Quel est le meilleur moyen d'y parvenir en Java?
Utilisez setRoundingMode , définissez explicitement le RoundingMode pour traiter votre problème avec le demi -Par ailleurs, utilisez le modèle de format pour la sortie requise.
Exemple:
DecimalFormat df = new DecimalFormat("#.####");
df.setRoundingMode(RoundingMode.CEILING);
for (Number n : Arrays.asList(12, 123.12345, 0.23, 0.1, 2341234.212431324)) {
Double d = n.doubleValue();
System.out.println(df.format(d));
}
donne le résultat:
12
123.1235
0.23
0.1
2341234.2125
En supposant que value est un double, vous pouvez faire:
(double)Math.round(value * 100000d) / 100000d
C'est pour une précision de 5 chiffres. Le nombre de zéros indique le nombre de décimales.
new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);
vous obtiendrez un BigDecimal. Pour en extraire la chaîne, appelez simplement la méthode BigDecimal de toString ou la méthode toPlainString de Java 5+ pour une chaîne au format standard.
Exemple de programme:
package trials;
import Java.math.BigDecimal;
public class Trials {
public static void main(String[] args) {
int yourScale = 10;
System.out.println(BigDecimal.valueOf(0.42344534534553453453-0.42324534524553453453).setScale(yourScale, BigDecimal.ROUND_HALF_UP));
}
Vous pouvez également utiliser le
DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);
pour vous assurer que vous avez les 0 derniers.
Comme d'autres l'ont noté, la bonne réponse consiste à utiliser soit DecimalFormat ou BigDecimal. La virgule flottante n'a pas de décimales, vous ne pouvez donc pas forcément arrondir/tronquer un nombre spécifique d'entre elles en premier lieu. Vous devez travailler avec une base décimale, et c’est ce que font ces deux classes.
Je publie le code suivant comme un contre-exemple de toutes les réponses de ce fil de discussion et de tout le reste de StackOverflow (et ailleurs) qui recommandent une multiplication suivie d'une troncature suivie d'une division. Il incombe aux défenseurs de cette technique d’expliquer pourquoi le code suivant produit une sortie erronée dans plus de 92% des cas.
public class RoundingCounterExample
{
static float roundOff(float x, int position)
{
float a = x;
double temp = Math.pow(10.0, position);
a *= temp;
a = Math.round(a);
return (a / (float)temp);
}
public static void main(String[] args)
{
float a = roundOff(0.0009434f,3);
System.out.println("a="+a+" (a % .001)="+(a % 0.001));
int count = 0, errors = 0;
for (double x = 0.0; x < 1; x += 0.0001)
{
count++;
double d = x;
int scale = 2;
double factor = Math.pow(10, scale);
d = Math.round(d * factor) / factor;
if ((d % 0.01) != 0.0)
{
System.out.println(d + " " + (d % 0.01));
errors++;
}
}
System.out.println(count + " trials " + errors + " errors");
}
}
Résultat de ce programme:
10001 trials 9251 errors
EDIT: Pour adresser quelques commentaires ci-dessous, j'ai refait la partie module de la boucle de test en utilisant BigDecimal et new MathContext(16) pour l'opération de module comme suit:
public static void main(String[] args)
{
int count = 0, errors = 0;
int scale = 2;
double factor = Math.pow(10, scale);
MathContext mc = new MathContext(16, RoundingMode.DOWN);
for (double x = 0.0; x < 1; x += 0.0001)
{
count++;
double d = x;
d = Math.round(d * factor) / factor;
BigDecimal bd = new BigDecimal(d, mc);
bd = bd.remainder(new BigDecimal("0.01"), mc);
if (bd.multiply(BigDecimal.valueOf(100)).remainder(BigDecimal.ONE, mc).compareTo(BigDecimal.ZERO) != 0)
{
System.out.println(d + " " + bd);
errors++;
}
}
System.out.println(count + " trials " + errors + " errors");
}
Résultat:
10001 trials 4401 errors
Supposons que vous ayez
double d = 9232.129394d;
vous pouvez utiliser BigDecimal
BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN);
d = bd.doubleValue();
ou sans BigDecimal
d = Math.round(d*100)/100.0d;
avec les deux solutions d == 9232.13
Vous pouvez utiliser la classe DecimalFormat.
double d = 3.76628729;
DecimalFormat newFormat = new DecimalFormat("#.##");
double twoDecimal = Double.valueOf(newFormat.format(d));
Real Java How-to posts cette solution, qui est également compatible avec les versions antérieures à Java 1.6.
BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();
double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;
@Milhous: le format décimal pour l'arrondi est excellent:
Vous pouvez également utiliser le
DecimalFormat df = new DecimalFormat("#.00000"); df.format(0.912385);pour vous assurer que vous avez les 0 derniers.
J'ajouterais que cette méthode est très efficace pour fournir un mécanisme d'arrondi numérique, non seulement visuellement, mais également lors du traitement.
Hypothétique: vous devez implémenter un mécanisme d'arrondi dans un programme d'interface graphique. Pour modifier l’exactitude/la précision d’une sortie de résultat, il suffit de changer le format d’ caret (c’est-à-dire entre crochets). Pour que:
DecimalFormat df = new DecimalFormat("#0.######");
df.format(0.912385);
renverrait en sortie: 0.912385
DecimalFormat df = new DecimalFormat("#0.#####");
df.format(0.912385);
renverrait en sortie: 0.91239
DecimalFormat df = new DecimalFormat("#0.####");
df.format(0.912385);
renverrait en sortie: 0.9124
[EDIT: également si le format de curseur est semblable ("# 0. ############") et que vous entrez une décimale, par exemple. 3.1415926, par souci d'argument, DecimalFormat ne produit pas d'ordures (par exemple, des zéros de fin) et renvoie: 3.1415926 .. si vous êtes de cette façon incliné. Certes, c'est un peu commenté pour le goût de certains développeurs - mais bon, il a une faible empreinte mémoire lors du traitement et est très facile à mettre en œuvre.]
Donc, l'essentiel de DecimalFormat réside dans le fait qu'il gère simultanément l'apparence de la chaîne - ainsi que le niveau de précision d'arrondi défini. Ergo: vous bénéficiez de deux avantages pour le prix d'une implémentation d'un code. ;)
Vous pouvez utiliser la méthode utilitaire suivante
public static double round(double valueToRound, int numberOfDecimalPlaces)
{
double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
double interestedInZeroDPs = valueToRound * multipicationFactor;
return Math.round(interestedInZeroDPs) / multipicationFactor;
}
Voici un résumé de ce que vous pouvez utiliser si vous voulez que le résultat soit sous forme de chaîne:
DecimalFormat # setRoundingMode () :
DecimalFormat df = new DecimalFormat("#.#####"); df.setRoundingMode(RoundingMode.HALF_UP); String str1 = df.format(0.912385)); // 0.91239String str2 = new BigDecimal(0.912385) .setScale(5, BigDecimal.ROUND_HALF_UP) .toString();
Voici une suggestion de quelles bibliothèques vous pouvez utiliser si vous voulez double en conséquence. Je ne le recommanderais toutefois pas pour la conversion de chaînes, car double pourrait ne pas être en mesure de représenter exactement ce que vous voulez (voir, par exemple, ici ):
Une solution succincte:
public static double round(double value, int precision) {
int scale = (int) Math.pow(10, precision);
return (double) Math.round(value * scale) / scale;
}
Voir aussi, https://stackoverflow.com/a/22186845/21295 Merci à jpdymond pour cette offre.
Vous pouvez utiliser BigDecimal
BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.UP);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.UP);
System.out.println(value + "n" + value1);
Voir: http://www.javabeat.net/precise-rounding-of-decimals-using-rounding-mode-enumeration/
Essayez ceci: org.Apache.commons.math3.util.Precision.round (double x, int scale)
Voir: http://commons.Apache.org/proper/commons-math/apidocs/org/Apache/commons/math3/util/Precision.html
La page d'accueil de la bibliothèque de mathématiques Apache Commons est la suivante: http://commons.Apache.org/proper/commons-math/index.html
L'implémentation interne de cette méthode est:
public static double round(double x, int scale) {
return round(x, scale, BigDecimal.ROUND_HALF_UP);
}
public static double round(double x, int scale, int roundingMethod) {
try {
return (new BigDecimal
(Double.toString(x))
.setScale(scale, roundingMethod))
.doubleValue();
} catch (NumberFormatException ex) {
if (Double.isInfinite(x)) {
return x;
} else {
return Double.NaN;
}
}
}
N'ayant trouvé aucune réponse complète sur ce thème, j'ai mis en place une classe qui devrait gérer cela correctement, avec prise en charge de:
- Formatage: formater facilement un double en chaîne avec un certain nombre de décimales
- Analyse: Analyser à nouveau la valeur formatée
- Locale: Formater et analyser en utilisant les paramètres régionaux par défaut
- notation exponentielle: commence à utiliser la notation exponentielle après un certain seuil
L'utilisation est assez simple:
(Pour les besoins de cet exemple, j'utilise des paramètres régionaux personnalisés)
public static final int DECIMAL_PLACES = 2;
NumberFormatter formatter = new NumberFormatter(DECIMAL_PLACES);
String value = formatter.format(9.319); // "9,32"
String value2 = formatter.format(0.0000005); // "5,00E-7"
String value3 = formatter.format(1324134123); // "1,32E9"
double parsedValue1 = formatter.parse("0,4E-2", 0); // 0.004
double parsedValue2 = formatter.parse("0,002", 0); // 0.002
double parsedValue3 = formatter.parse("3423,12345", 0); // 3423.12345
Voici la classe:
import Java.math.RoundingMode;
import Java.text.DecimalFormat;
import Java.text.DecimalFormatSymbols;
import Java.text.ParseException;
import Java.util.Locale;
public class NumberFormatter {
private static final String SYMBOL_INFINITE = "\u221e";
private static final char SYMBOL_MINUS = '-';
private static final char SYMBOL_ZERO = '0';
private static final int DECIMAL_LEADING_GROUPS = 10;
private static final int EXPONENTIAL_INT_THRESHOLD = 1000000000; // After this value switch to exponential notation
private static final double EXPONENTIAL_DEC_THRESHOLD = 0.0001; // Below this value switch to exponential notation
private DecimalFormat decimalFormat;
private DecimalFormat decimalFormatLong;
private DecimalFormat exponentialFormat;
private char groupSeparator;
public NumberFormatter(int decimalPlaces) {
configureDecimalPlaces(decimalPlaces);
}
public void configureDecimalPlaces(int decimalPlaces) {
if (decimalPlaces <= 0) {
throw new IllegalArgumentException("Invalid decimal places");
}
DecimalFormatSymbols separators = new DecimalFormatSymbols(Locale.getDefault());
separators.setMinusSign(SYMBOL_MINUS);
separators.setZeroDigit(SYMBOL_ZERO);
groupSeparator = separators.getGroupingSeparator();
StringBuilder decimal = new StringBuilder();
StringBuilder exponential = new StringBuilder("0.");
for (int i = 0; i < DECIMAL_LEADING_GROUPS; i++) {
decimal.append("###").append(i == DECIMAL_LEADING_GROUPS - 1 ? "." : ",");
}
for (int i = 0; i < decimalPlaces; i++) {
decimal.append("#");
exponential.append("0");
}
exponential.append("E0");
decimalFormat = new DecimalFormat(decimal.toString(), separators);
decimalFormatLong = new DecimalFormat(decimal.append("####").toString(), separators);
exponentialFormat = new DecimalFormat(exponential.toString(), separators);
decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
decimalFormatLong.setRoundingMode(RoundingMode.HALF_UP);
exponentialFormat.setRoundingMode(RoundingMode.HALF_UP);
}
public String format(double value) {
String result;
if (Double.isNaN(value)) {
result = "";
} else if (Double.isInfinite(value)) {
result = String.valueOf(SYMBOL_INFINITE);
} else {
double absValue = Math.abs(value);
if (absValue >= 1) {
if (absValue >= EXPONENTIAL_INT_THRESHOLD) {
value = Math.floor(value);
result = exponentialFormat.format(value);
} else {
result = decimalFormat.format(value);
}
} else if (absValue < 1 && absValue > 0) {
if (absValue >= EXPONENTIAL_DEC_THRESHOLD) {
result = decimalFormat.format(value);
if (result.equalsIgnoreCase("0")) {
result = decimalFormatLong.format(value);
}
} else {
result = exponentialFormat.format(value);
}
} else {
result = "0";
}
}
return result;
}
public String formatWithoutGroupSeparators(double value) {
return removeGroupSeparators(format(value));
}
public double parse(String value, double defValue) {
try {
return decimalFormat.parse(value).doubleValue();
} catch (ParseException e) {
e.printStackTrace();
}
return defValue;
}
private String removeGroupSeparators(String number) {
return number.replace(String.valueOf(groupSeparator), "");
}
}
Si vous voulez vraiment des nombres décimaux pour le calcul (et pas seulement pour la sortie), n'utilisez pas un format à virgule flottante à base binaire comme double.
Use BigDecimal or any other decimal-based format.
J'utilise BigDecimal pour les calculs, mais gardez à l'esprit que cela dépend de la taille des nombres que vous traitez. Dans la plupart de mes implémentations, je trouve que l'analyse syntaxique de double ou entier à Long est suffisante pour les calculs de très grands nombres.
En fait, j'ai récemment utilisé l'analyse syntaxique pour obtenir des représentations précises (par opposition aux résultats hexadécimaux) dans une interface utilisateur graphique pour des nombres aussi grands que ################## ################ caractères (à titre d'exemple).
Juste au cas où quelqu'un aurait encore besoin d'aide avec ça. Cette solution fonctionne parfaitement pour moi.
private String withNoTrailingZeros(final double value, final int nrOfDecimals) {
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();
}
renvoie un String avec la sortie désirée.
Pour ce faire, nous pouvons utiliser ce formateur:
DecimalFormat df = new DecimalFormat("#.00");
String resultado = df.format(valor)
ou:
DecimalFormat df = new DecimalFormat("0.00"); :
Utilisez cette méthode pour obtenir toujours deux décimales:
private static String getTwoDecimals(double value){
DecimalFormat df = new DecimalFormat("0.00");
return df.format(value);
}
Définir ces valeurs:
91.32
5.22
11.5
1.2
2.6
En utilisant la méthode, nous pouvons obtenir ces résultats:
91.32
5.22
11.50
1.20
2.60
Si vous utilisez DecimalFormat pour convertir double en String, c'est très simple:
DecimalFormat formatter = new DecimalFormat("0.0##");
formatter.setRoundingMode(RoundingMode.HALF_UP);
double num = 1.234567;
return formatter.format(num);
Il existe plusieurs valeurs RoundingMode enum parmi lesquelles choisir, en fonction du comportement souhaité.
Je suis d'accord avec la réponse choisie d'utiliser DecimalFormat --- ou alternativement BigDecimal.
Veuillez lire Mettez à jour ci-dessous en premier!
Toutefois, si vous voulez arrondir la valeur double et obtenir un résultat double valeur, vous pouvez utiliser org.Apache.commons.math3.util.Precision.round(..) comme indiqué ci-dessus. L'implémentation utilise BigDecimal, est lente et crée des déchets.
Une méthode similaire mais rapide et sans déchets est fournie par l'utilitaire DoubleRounder de la bibliothèque decimal4j:
double a = DoubleRounder.round(2.0/3.0, 3);
double b = DoubleRounder.round(2.0/3.0, 3, RoundingMode.DOWN);
double c = DoubleRounder.round(1000.0d, 17);
double d = DoubleRounder.round(90080070060.1d, 9);
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
Sortie
0.667
0.666
1000.0
9.00800700601E10
Voir https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility
Avertissement: Je suis impliqué dans le projet decimal4j.
Mise à jour: Comme @iaforek l'a souligné, DoubleRounder renvoie parfois des résultats contre-intuitifs. La raison en est qu'il effectue un arrondi mathématiquement correct. Par exemple, DoubleRounder.round(256.025d, 2) sera arrondi à 256.02 car la valeur double représentée par 256.025d est légèrement inférieure à la valeur rationnelle 256.025 et sera donc arrondie.
Notes:
- Ce comportement est très similaire à celui du constructeur
BigDecimal(double)(mais pas àvalueOf(double)qui utilise le constructeur de chaîne). - Le problème peut être contourné avec un premier pas d’arrondi double vers une précision supérieure, mais c’est compliqué et je ne vais pas entrer dans les détails ici.
Pour ces raisons et tout ce qui est mentionné ci-dessus dans ce message, je ne peux pas recommander l'utilisation de DoubleRounder .
L'extrait de code ci-dessous montre comment afficher n chiffres. L'astuce consiste à définir la variable pp sur 1 suivie de n zéros. Dans l'exemple ci-dessous, la valeur de la variable pp comporte 5 zéros, ainsi 5 chiffres seront affichés.
double pp = 10000;
double myVal = 22.268699999999967;
String needVal = "22.2687";
double i = (5.0/pp);
String format = "%10.4f";
String getVal = String.format(format,(Math.round((myVal +i)*pp)/pp)-i).trim();
Je suis venu ici simplement pour une réponse simple sur la manière d'arrondir un nombre. Ceci est une réponse supplémentaire à fournir.
Comment arrondir un nombre en Java
Le cas le plus courant consiste à utiliser Math.round().
Math.round(3.7) // 4
Les nombres sont arrondis au nombre entier le plus proche. Une valeur .5 est arrondie. Si vous avez besoin d'un comportement d'arrondi différent, vous pouvez utiliser l'une des autres fonctions Math . Voir la comparaison ci-dessous.
rond
Comme indiqué ci-dessus, ceci arrondit au nombre entier le plus proche. .5 décimales arrondies. Cette méthode retourne un int.
Math.round(3.0); // 3
Math.round(3.1); // 3
Math.round(3.5); // 4
Math.round(3.9); // 4
Math.round(-3.0); // -3
Math.round(-3.1); // -3
Math.round(-3.5); // -3 *** careful here ***
Math.round(-3.9); // -4
ceil
Toute valeur décimale est arrondie au nombre entier supérieur suivant. Il va au ceil ing. Cette méthode retourne un double.
Math.ceil(3.0); // 3.0
Math.ceil(3.1); // 4.0
Math.ceil(3.5); // 4.0
Math.ceil(3.9); // 4.0
Math.ceil(-3.0); // -3.0
Math.ceil(-3.1); // -3.0
Math.ceil(-3.5); // -3.0
Math.ceil(-3.9); // -3.0
étage
Toute valeur décimale est arrondie au nombre entier inférieur. Cette méthode retourne un double.
Math.floor(3.0); // 3.0
Math.floor(3.1); // 3.0
Math.floor(3.5); // 3.0
Math.floor(3.9); // 3.0
Math.floor(-3.0); // -3.0
Math.floor(-3.1); // -4.0
Math.floor(-3.5); // -4.0
Math.floor(-3.9); // -4.0
rint
Ceci est similaire à arrondir en ce que les valeurs décimales arrondies à l'entier le plus proche. Cependant, contrairement à round, .5 les valeurs sont arrondies à l'entier pair. Cette méthode retourne un double.
Math.rint(3.0); // 3.0
Math.rint(3.1); // 3.0
Math.rint(3.5); // 4.0 ***
Math.rint(3.9); // 4.0
Math.rint(4.5); // 4.0 ***
Math.rint(5.5); // 6.0 ***
Math.rint(-3.0); // -3.0
Math.rint(-3.1); // -3.0
Math.rint(-3.5); // -4.0 ***
Math.rint(-3.9); // -4.0
Math.rint(-4.5); // -4.0 ***
Math.rint(-5.5); // -6.0 ***
Si vous utilisez une technologie qui a un JDK minimal. Voici un moyen sans Java libs:
double scale = 100000;
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;
DecimalFormat est le meilleur moyen de générer des résultats, mais je ne le préfère pas. Je fais toujours cela tout le temps, parce que ça retourne la double valeur. Je peux donc l'utiliser plus que la simple sortie.
Math.round(selfEvaluate*100000d.0)/100000d.0;
OR
Math.round(selfEvaluate*100000d.0)*0.00000d1;
Si vous avez besoin d'une valeur de grand nombre de décimales, vous pouvez utiliser BigDecimal à la place. Quoi qu'il en soit, .0 est important. Sans cela, l’arrondi de 0.33333d5 renvoie 0.33333 et seulement 9 chiffres sont autorisés. La deuxième fonction sans .0 a des problèmes avec 0.30000 return 0.30000000000000004.
En général, l’arrondi se fait en mettant à l’échelle: round(num / p) * p
/**
* MidpointRounding away from zero ('arithmetic' rounding)
* Uses a half-epsilon for correction. (This offsets IEEE-754
* half-to-even rounding that was applied at the Edge cases).
*/
double RoundCorrect(double num, int precision) {
double c = 0.5 * EPSILON * num;
// double p = Math.pow(10, precision); //slow
double p = 1; while (precision--> 0) p *= 10;
if (num < 0)
p *= -1;
return Math.round((num + c) * p) / p;
}
// testing Edge cases
RoundCorrect(1.005, 2); // 1.01 correct
RoundCorrect(2.175, 2); // 2.18 correct
RoundCorrect(5.015, 2); // 5.02 correct
RoundCorrect(-1.005, 2); // -1.01 correct
RoundCorrect(-2.175, 2); // -2.18 correct
RoundCorrect(-5.015, 2); // -5.02 correct
Si vous considérez 5 ou n nombre de décimales. Peut-être que cette réponse résoudra votre problème.
double a = 123.00449;
double roundOff1 = Math.round(a*10000)/10000.00;
double roundOff2 = Math.round(roundOff1*1000)/1000.00;
double roundOff = Math.round(roundOff2*100)/100.00;
System.out.println("result:"+roundOff);
La sortie sera: 123.0 1
Cela peut être résolu avec une fonction en boucle et récursive.
voici ma réponse:
double num = 4.898979485566356;
DecimalFormat df = new DecimalFormat("#.##");
time = Double.valueOf(df.format(num));
System.out.println(num); // 4.89
Gardez à l'esprit que String.format () et DecimalFormat produisent une chaîne à l'aide de l'option Locale par défaut. Ainsi, ils peuvent écrire un nombre formaté avec un point ou une virgule comme séparateur entre les parties entières et décimales. Pour vous assurer que la chaîne arrondie est dans le format souhaité, utilisez Java.text.NumberFormat comme suit:
Locale locale = Locale.ENGLISH;
NumberFormat nf = NumberFormat.getNumberInstance(locale);
// for trailing zeros:
nf.setMinimumFractionDigits(2);
// round to 2 digits:
nf.setMaximumFractionDigits(2);
System.out.println(nf.format(.99));
System.out.println(nf.format(123.567));
System.out.println(nf.format(123.0));
Imprimera dans les paramètres régionaux anglais (quels que soient vos paramètres): 0.99 123.57 123.00
L'exemple est pris de Farenda - comment convertir un double en chaîne correctement .
Où dp = le point décimal que vous voulez et valeur est un double.
double p = Math.pow(10d, dp);
double result = Math.round(value * p)/p;