Voici ce que j'ai fait pour arrondir un double à deux décimales:
amount = roundTwoDecimals(amount);
public double roundTwoDecimals(double d) {
DecimalFormat twoDForm = new DecimalFormat("#.##");
return Double.valueOf(twoDForm.format(d));
}
Cela fonctionne très bien si le montant = 25,3569 ou quelque chose comme ça, mais si le montant = 25,00 ou le montant = 25,0, alors je reçois 25,0! Ce que je veux, c'est à la fois arrondir et formater à 2 décimales.
Travaillez-vous avec de l'argent? Créer une String
et ensuite la reconvertir est très compliqué.
Utilisez BigDecimal
. Cela a été discuté assez longuement. Vous devriez avoir une classe Money
et le montant doit être un BigDecimal
.
Même si vous ne travaillez pas avec de l'argent, considérez BigDecimal
.
Il suffit d'utiliser: (facile comme bonjour)
double number = 651.5176515121351;
number = Math.round(number * 100);
number = number/100;
La sortie sera 651.52
Utilisez un espace réservé aux chiffres (0
), car avec '#
', les zéros de tête/premiers indiquent les absents:
DecimalFormat twoDForm = new DecimalFormat("#.00");
Vous ne pouvez pas 'arrondissez un double à [un nombre quelconque de] décimales', car les doubles n'ont pas de décimales. Vous pouvez convertir un double en chaîne base-10 avec N décimales, car le format base-10 a des décimales, mais lorsque vous le convertissez, vous revenez en double-terre, avec binary fractional.
Utilisez ceci
String.format ("%. 2f", doubleValue) // change 2, selon vos besoins.
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.
Vous pouvez utiliser org.Apache.commons.math.util.MathUtils 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)
montant double = 25,00;
NumberFormat formatter = new DecimalFormat ("# 0.00");
System.out.println (formatter.format (quantité));
DecimalFormat df = new DecimalFormat("###.##");
double total = Double.valueOf(val);
Votre classe Money pourrait être représentée comme une sous-classe de Long ou avoir un membre représentant la valeur de l’argent comme un natif long. Ensuite, lors de l'affectation de valeurs à vos instanciations d'argent, vous enregistrerez toujours des valeurs qui sont en réalité des valeurs d'argent RÉELLES. Vous produisez simplement votre objet Money (via la méthode toString () de votre Money) avec le formatage approprié. Par exemple, 1,25 USD dans la représentation interne d'un objet Money est égal à 125. Vous représentez l'argent en cents, en penny ou quelle que soit la dénomination minimale dans la devise que vous scellez est ... puis formatez-le en sortie. Non, vous ne pouvez JAMAIS stocker une valeur «illégale», comme par exemple 1,257 USD.
Commencez par déclarer un objet de la classe DecimalFormat
. Notez que l'argument à l'intérieur de DecimalFormat
est #.00
, ce qui signifie exactement 2 décimales arrondies.
private static DecimalFormat df2 = new DecimalFormat("#.00");
Maintenant, appliquez le format à votre double valeur:
double input = 32.123456;
System.out.println("double : " + df2.format(input)); // Output: 32.12
Remarque dans le cas de double input = 32.1;
La sortie serait alors 32.10
et ainsi de suite.
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(String[] args) {
System.out.println(new DecimalFormat("0.00").format(myFixedNumber));
}
}
Le résultat est:98765.43
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.toString (double) corrigera 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 arrondi implicitement. ;)
où num est le double nombre
Ici nous prenons 2 palces décimales
System.out.printf ("%. 2f", num);
Vous pouvez utiliser cette fonction.
import org.Apache.commons.lang.StringUtils;
public static double roundToDecimals(double number, int c)
{
String rightPad = StringUtils.rightPad("1", c+1, "0");
int decimalPoint = Integer.parseInt(rightPad);
number = Math.round(number * decimalPoint);
return number/decimalPoint;
}
À partir de Java 1.8, vous pouvez en faire plus avec les expressions lambda et vérifie la valeur null. En outre, l’une des options ci-dessous peut gérer un nombre à virgule flottante ou double et variable (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);
}
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));
En supposant que le montant puisse être positif ou négatif, l’extrait de code suivant peut être arrondi à deux décimales.
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);
}
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;
}
}
void "test double format"(){
given:
Double performance = 0.6666666666666666
when:
Double formattedPerformance = Util.formatDouble(performance)
println "######################## formatted ######################### => ${formattedPerformance}"
then:
0.67 == formattedPerformance
}
Vous pouvez essayer celui-ci:
public static String getRoundedValue(Double value, String 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;
}