Как округлить двойной до двух десятичных знаков в Java?

просто используйте: (легко, как пирог)

double number = 651.5176515121351;

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

выход будет 651.52

используйте держатель места цифры (0), а с '#' конечные / ведущие нули отображаются как отсутствующие:

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

вы Не могу 'вокруг двойника к [любому количеству] десятичных знаков', потому что двойники не имеют десятичных знаков. Вы можете преобразовать double в строку base-10 С N десятичными знаками, потому что base-10 действительно имеет десятичные знаки, но когда вы преобразуете его обратно, вы возвращаетесь в double-land, с binary частичная места.

Это самый простой я мог бы сделать это, но он получает работу намного проще, чем большинство примеров, которые я видел.

    double total = 1.4563;

    total = Math.round(total * 100);

    System.out.println(total / 100);

результат 1.46.

использовать

строку.формат.%"(2Ф", doubleValue) // изменение 2, согласно вашему требованию.

вы можете использовать org.апаш.палата общин.математика.утиль.MathUtils от apache common

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

вы можете использовать Apache Commons Math:

Precision.round(double x, int scale)

источник: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html#round(double,%20int)

ваш класс Money может быть представлен как подкласс Long или иметь член, представляющий денежную ценность как собственный long. Затем при присвоении значений вашим денежным экземплярам вы всегда будете хранить значения, которые на самом деле являются реальными денежными значениями. Вы просто выводите свой объект Money (через переопределенный метод toString() Ваших денег) с соответствующим форматированием. например, $ 1.25 во внутреннем представлении денежного объекта составляет 125. Вы представляете деньги в виде центов, или пенсов, или независимо от минимального номинала в валюте, которую вы запечатываете, есть ... затем отформатируйте его на выходе. Нет, вы никогда не можете хранить "незаконную" денежную ценность, например, $1.257.

двойная сумма = 25.00;

numberformat formatter = new DecimalFormat ("#0.00");

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

Если вы хотите, чтобы результат до двух знаков после запятой вы можете сделать

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

этот результат не является точным, но двойной.toString (double) исправит это и выведет от одного до двух знаков после запятой. Однако, как только вы выполните другой расчет, вы можете получить результат, который не будет неявно округлые. ;)

Math.round один ответ,

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

тест в Spock, Groovy

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

}

предполагая, что сумма может быть как положительной, так и отрицательной, округление до двух десятичных знаков может использовать следующий фрагмент кода.

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);
}

запуск java 1.8 вы можете сделать больше с помощью лямбда-выражений и проверок на null. Кроме того, один ниже может обрабатывать Float или Double & переменное количество десятичных знаков (в том числе 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);
}

где num-двойное число

• целое число 2 обозначает количество десятичных знаков, которые мы хотим напечатать.

• здесь мы берем 2 десятичных пальца

Вы можете попробовать это:

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);
}

или

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;
}

вот простой способ, который гарантирует вывод myFixedNumber округлены до двух знаков после запятой:

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));
    }
}

результат: 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));

сначала объявите объект DecimalFormat класса. Обратите внимание на аргумент внутри DecimalFormat и #.00 что означает ровно 2 десятичных знака округления.

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

теперь примените формат к вашему двойному значению:

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

Примечание. В случае double input = 32.1;

тогда выход будет 32.10 и так далее.