@米尔豪斯：舍入的十进制格式非常好：

您也可以使用DecimalFormat df=新的DecimalFormat（“#.000000”）；df.格式（0.912385）；以确保后面有0。

我想补充一点，这种方法非常善于提供数字、舍入机制-不仅是视觉上的，也是处理时的。

假设：您必须在GUI中实现舍入机制程序只需更改结果输出的精度更改插入符号格式（即在括号内）。以便：

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

[EDIT：如果插入符号格式是这样的（“#0.#############”）为参数起见，输入小数，例如3.1415926，DecimalFormat不产生任何垃圾（例如尾随零），并将返回：3.1415926…如果你有这种倾向。当然，这有点冗长对于一些开发人员来说-但是，嘿，它的内存占用量很低在处理过程中，并且非常容易实现。]

因此本质上，DecimalFormat的优点在于它同时处理字符串外观-以及舍入精度设置的级别。埃尔戈：你以一个代码实现的价格获得两个好处

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

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

您可以使用以下实用程序方法-

public static double round(double valueToRound, int numberOfDecimalPlaces)
{
    double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
    double interestedInZeroDPs = valueToRound * multipicationFactor;
    return Math.round(interestedInZeroDPs) / multipicationFactor;
}

一种简单的比较方法，如果小数位数有限。我们可以使用Casting来代替DecimalFormat、Math或BigDecimal！

这是样品，

public static boolean threeDecimalPlaces(double value1, double value2){
    boolean isEqual = false;
    // value1 = 3.1756 
    // value2 = 3.17
    //(int) (value1 * 1000) = 3175
    //(int) (value2 * 1000) = 3170

    if ((int) (value1 * 1000) == (int) (value2 * 1000)){
        areEqual = true;
    }

    return isEqual;
}

我同意使用DecimalFormat或BigDecimal的答案。

请先阅读下面的更新！

但是，如果您确实希望舍入双值并获得双值结果，则可以使用上述org.apache.commons.math3.util.Precision.round（..）。该实现使用BigDecimal，速度慢，并且会产生垃圾。

decimal4j库中的DoubleRounder实用程序提供了一种类似但快速且无垃圾的方法：

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

将输出

 0.667
 0.666
 1000.0
 9.00800700601E10

看见https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility

披露：我参与了decimal4j项目。

更新：正如@iaforek指出的那样，DoubleRounder有时会返回违反直觉的结果。原因是它执行数学上正确的舍入。例如，DoubleRounder.round（256.025d，2）将向下舍入到256.02，因为表示为256.025d的双精度值略小于有理值256.025，因此将向下舍入。

笔记：

这种行为与BigDecimal（double）构造函数非常相似（但与使用字符串构造函数的valueOf（double）不同）。这个问题可以先用双倍的舍入步骤以更高的精度来解决，但它很复杂，我不打算在这里讨论细节

出于这些原因以及本文中提到的所有内容，我不建议使用DoubleRounder。

我来这里只是想得到一个关于如何舍入数字的简单答案。这是提供这一点的补充答案。

如何在Java中舍入数字

最常见的情况是使用Math.rround（）。

Math.round(3.7) // 4

数字四舍五入到最接近的整数。A.5值向上舍入。如果需要不同的舍入行为，可以使用其他数学函数之一。请参阅下面的比较。

圆形的

如上所述，这四舍五入到最接近的整数。5位小数向上舍入。此方法返回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

任何十进制值都将舍入到下一个整数。它通向天花板。此方法返回一个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

地板

任何十进制值都向下舍入到下一个整数。此方法返回一个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

这与舍入相似，因为十进制值舍入到最接近的整数。然而，与舍入不同，.5值舍入为偶数。此方法返回一个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 ***