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

Если вы используете технологию, которая имеет минимальный JDK. Вот способ без каких-либо библиотек Java:

double scale = 100000;    
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;

Вы также можете использовать

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

, чтобы убедиться, что у вас есть конечные 0.

double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;

Инструкции Real Java по опубликовали это решение, которое также совместимо с версиями до Java 1.6.

BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();

Для достижения этого мы можем использовать этот форматер:

 DecimalFormat df = new DecimalFormat("#.00");
 String resultado = df.format(valor)

или:

DecimalFormat df = new DecimalFormat("0.00"); :

Используйте этот метод, чтобы получить всегда два десятичных знака:

   private static String getTwoDecimals(double value){
      DecimalFormat df = new DecimalFormat("0.00"); 
      return df.format(value);
    }

Определение этих значений:

91.32
5.22
11.5
1.2
2.6

Используя метод, мы можем получить следующие результаты:

91.32
5.22
11.50
1.20
2.60

демо онлайн.

Если вы используете DecimalFormat для преобразования double в String, это очень просто:

DecimalFormat formatter = new DecimalFormat("0.0##");
formatter.setRoundingMode(RoundingMode.HALF_UP);

double num = 1.234567;
return formatter.format(num);

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

Предполагая, что value является double, вы можете сделать:

(double)Math.round(value * 100000d) / 100000d

Это для точности 5 цифр. Количество нулей указывает количество десятичных знаков.

new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);

получит Вас BigDecimal. Для вытаскивания строки из него просто назовите это BigDecimal toString метод, или toPlainString метод для Java 5 + для простой строки формата.

Пример программы:

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

Предположим, у вас есть

double d = 9232.129394d;

, вы можете использовать BigDecimal

BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN);
d = bd.doubleValue();

или без BigDecimal

d = Math.round(d*100)/100.0d;

с обоими решения d == 9232.13

@Milhous: превосходный десятичный формат для округления:

Вы также можете использовать

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

, чтобы убедиться, что у вас есть конечные 0.

Я хотел бы добавить, что этот метод очень хорош в обеспечении фактического числового механизма округления - не только визуально, но и при обработке.

Гипотетический: вам нужно внедрить механизм округления в программу с графическим интерфейсом. Чтобы изменить точность / точность вывода результата, просто измените формат каретки (то есть в скобках). Таким образом:

DecimalFormat df = new DecimalFormat("#0.######");
df.format(0.912385);

вернется в качестве выхода: 0.912385

DecimalFormat df = new DecimalFormat("#0.#####");
df.format(0.912385);

вернется в качестве выхода: 0.91239

DecimalFormat df = new DecimalFormat("#0.####");
df.format(0.912385);

вернется в качестве выхода : 0.9124

[РЕДАКТИРОВАТЬ: также, если формат каретки похож на («# 0. ############»), и вы вводите десятичную дробь, например 3.1415926, ради аргумента, DecimalFormat не производит никакого мусора (например, конечные нули) и возвращает: 3.1415926 .. если вы склонны к этому. Конечно, это немного многословно для симпатий некоторых разработчиков - но, эй, у него небольшой объем памяти во время обработки и его очень легко реализовать.]

По сути, прелесть DecimalFormat заключается в том, что он одновременно обрабатывает внешний вид строки - а также уровень точности округления. Ergo: вы получаете два преимущества по цене одной реализации кода. ;)

Вот краткое изложение того, что вы можете использовать, если хотите получить результат в виде строки:

1. DecimalFormat # setRoundingMode () :

   DecimalFormat df = new DecimalFormat("#.#####");
   df.setRoundingMode(RoundingMode.HALF_UP);
   String str1 = df.format(0.912385)); // 0.91239
   

2. BigDecimal # setScale ()

   String str2 = new BigDecimal(0.912385)
       .setScale(5, BigDecimal.ROUND_HALF_UP)
       .toString();
   

Вот предложение о том, какие библиотеки вы можете использовать, если хотите double в следствии. Я бы не рекомендовал это для преобразования строк, так как double может быть не в состоянии точно представить, что вы хотите (см., Например, здесь ):

1. Precision из Apache Commons Math

   double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP);
   

2. Функции из Colt

   double rounded = Functions.round(0.00001).apply(0.912385)
   

3. ] Утильс из Века

   double rounded = Utils.roundDouble(0.912385, 5)
   

Если учесть 5 или n десятичных чисел. Может быть, этот ответ решит вашу проблему.

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

Вывод будет: 123.0 1
, это можно решить с помощью цикла и рекурсивной функции.

вот мой ответ:

double num = 4.898979485566356;
DecimalFormat df = new DecimalFormat("#.##");      
time = Double.valueOf(df.format(num));

System.out.println(num); // 4.89