这是我发现的只显示两位小数的最简单方法。

double x = 123.123;
System.out.printf( "%.2f", x );

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

您也可以使用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的优点在于它同时处理字符串外观-以及舍入精度设置的级别。埃尔戈：你以一个代码实现的价格获得两个好处

正如其他人所指出的，正确的答案是使用DecimalFormat或BigDecimal。浮点没有小数位数，因此您不可能在第一位舍入/截断为小数位数。你必须使用十进制基数，这就是这两个类的作用。

我发布以下代码作为本线程中所有答案的反例，实际上在StackOverflow（以及其他地方）中都建议先乘法后截断再除法。这项技术的拥护者有责任解释为什么以下代码在92%以上的情况下产生错误的输出。

public class RoundingCounterExample
{

    static float roundOff(float x, int position)
    {
        float a = x;
        double temp = Math.pow(10.0, position);
        a *= temp;
        a = Math.round(a);
        return (a / (float)temp);
    }

    public static void main(String[] args)
    {
        float a = roundOff(0.0009434f,3);
        System.out.println("a="+a+" (a % .001)="+(a % 0.001));
        int count = 0, errors = 0;
        for (double x = 0.0; x < 1; x += 0.0001)
        {
            count++;
            double d = x;
            int scale = 2;
            double factor = Math.pow(10, scale);
            d = Math.round(d * factor) / factor;
            if ((d % 0.01) != 0.0)
            {
                System.out.println(d + " " + (d % 0.01));
                errors++;
            }
        }
        System.out.println(count + " trials " + errors + " errors");
    }
}

本程序的输出：

10001 trials 9251 errors

编辑：为了解决下面的一些问题，我使用BigDecimal和新的MathContext（16）重新定义了测试循环的模部分，如下所示：

public static void main(String[] args)
{
    int count = 0, errors = 0;
    int scale = 2;
    double factor = Math.pow(10, scale);
    MathContext mc = new MathContext(16, RoundingMode.DOWN);
    for (double x = 0.0; x < 1; x += 0.0001)
    {
        count++;
        double d = x;
        d = Math.round(d * factor) / factor;
        BigDecimal bd = new BigDecimal(d, mc);
        bd = bd.remainder(new BigDecimal("0.01"), mc);
        if (bd.multiply(BigDecimal.valueOf(100)).remainder(BigDecimal.ONE, mc).compareTo(BigDecimal.ZERO) != 0)
        {
            System.out.println(d + " " + bd);
            errors++;
        }
    }
    System.out.println(count + " trials " + errors + " errors");
}

结果：

10001 trials 4401 errors

我的答案是：

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

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

因此，在阅读了大部分答案后，我意识到其中大多数答案都不精确，事实上，使用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的预期产量。

这里有一个更好的函数，它可以正确地舍入像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