假设值是双倍的，您可以执行以下操作：

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

这是5位数精度。零的数量表示小数的数量。

这里有一个更好的函数，它可以正确地舍入像1.005这样的边缘情况。

简单地说，我们在舍入之前将最小的浮点值（=1 ulp；单位在最后一位）添加到数字上。这将移动到数字之后的下一个可表示值，远离零。

这是一个测试它的小程序：ideone.com

/**
 * Round half away from zero ('commercial' rounding)
 * Uses correction to offset floating-point inaccuracies.
 * Works symmetrically for positive and negative numbers.
 */
public static double round(double num, int digits) {

    // epsilon correction
    double n = Double.longBitsToDouble(Double.doubleToLongBits(num) + 1);
    double p = Math.pow(10, digits);
    return Math.round(n * p) / p;
}

// test rounding of half
System.out.println(round(0.5, 0));   // 1
System.out.println(round(-0.5, 0));  // -1

// testing edge cases
System.out.println(round(1.005, 2));   // 1.01
System.out.println(round(2.175, 2));   // 2.18
System.out.println(round(5.015, 2));   // 5.02

System.out.println(round(-1.005, 2));  // -1.01
System.out.println(round(-2.175, 2));  // -2.18
System.out.println(round(-5.015, 2));  // -5.02

因此，在阅读了大部分答案后，我意识到其中大多数答案都不精确，事实上，使用BigDecimal似乎是最佳选择，但如果你不了解RoundingMode的工作原理，你将不可避免地失去精度。我在一个项目中处理大数字时发现了这一点，并认为这可以帮助其他有舍入问题的人。例如

BigDecimal bd = new BigDecimal("1363.2749");
bd = bd.setScale(2, RoundingMode.HALF_UP);
System.out.println(bd.doubleValue());

您希望得到1363.28作为输出，但如果您不知道RoundingMode在做什么，则最终会得到1363.27，这是不期望的。因此，查看Oracle文档，您将发现RoundingMode.HALF_UP的以下描述。

四舍五入模式向“最近邻居”舍入，除非两者都邻居是等距的，在这种情况下是四舍五入的。

所以知道了这一点，我们意识到除非我们想向最近的邻居取整，否则我们不会得到精确的舍入。因此，为了完成一个足够的循环，我们需要从n-1小数循环到所需的小数位数。例如

private double round(double value, int places) throws IllegalArgumentException {

    if (places < 0) throw new IllegalArgumentException();

    // Cast the number to a String and then separate the decimals.
    String stringValue = Double.toString(value);
    String decimals = stringValue.split("\\.")[1];

    // Round all the way to the desired number.
    BigDecimal bd = new BigDecimal(stringValue);
    for (int i = decimals.length()-1; i >= places; i--) {
        bd = bd.setScale(i, RoundingMode.HALF_UP);
    }

    return bd.doubleValue();
}

这将最终为我们提供1363.28的预期产量。

当尝试舍入到小数位数的负数时，Math.round解决方案存在问题。考虑代码

long l = 10;
for(int dp = -1; dp > -10; --dp) {
    double mul = Math.pow(10,dp);
    double res = Math.round(l * mul) / mul;
    System.out.println(""+l+" rounded to "+dp+" dp = "+res);
    l *=10;
}

这是结果

10 rounded to -1 dp = 10.0
100 rounded to -2 dp = 100.0
1000 rounded to -3 dp = 1000.0
10000 rounded to -4 dp = 10000.0
100000 rounded to -5 dp = 99999.99999999999
1000000 rounded to -6 dp = 1000000.0
10000000 rounded to -7 dp = 1.0E7
100000000 rounded to -8 dp = 1.0E8
1000000000 rounded to -9 dp = 9.999999999999999E8

当1除以1.0E-5时会出现小数位数为-5的问题，这是不精确的。

可以使用

double mul = Math.pow(10,dp);
double res;
if(dp < 0 ) {
    double div = Math.pow(10,-dp);
    res = Math.round(l * mul) *div;
} else {
    res = Math.round(l * mul) / mul;
}

但这是使用BigDecimal方法的另一个原因。

如果您使用的是JDK最小的技术。这里有一种没有任何Java库的方法：

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

我的答案是：

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

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