我想要的是一种将双精度转换为字符串的方法，该字符串使用半向上舍入方法进行舍入-即，如果要舍入的小数为5，则始终向上舍入到下一个数字。这是大多数人在大多数情况下所期望的四舍五入的标准方法。
我还希望只显示有效数字，即不应有任何尾随零。
我知道这样做的一种方法是使用String.format方法：
String.format("%.5g%n", 0.912385);
返回：
0.91239
这是很好的，但是它总是显示带有5位小数的数字，即使它们不重要：
String.format("%.5g%n", 0.912300);
返回：
0.91230
另一种方法是使用DecimalFormatter：
DecimalFormat df = new DecimalFormat("#.#####");
df.format(0.912385);
返回：
0.91238
然而，正如您所见，这使用了半偶数舍入。也就是说，如果前一个数字是偶数，它将向下舍入。我想要的是：
0.912385 -> 0.91239
0.912300 -> 0.9123
在Java中实现这一点的最佳方法是什么？
这里有一个更好的函数，它可以正确地舍入像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
试试看：org.apache.commons.math3.util.Precision.round（双x，int scale）
参见：http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html
Apache Commons数学图书馆主页：http://commons.apache.org/proper/commons-math/index.html
该方法的内部实现是：
public static double round(double x, int scale) {
return round(x, scale, BigDecimal.ROUND_HALF_UP);
}
public static double round(double x, int scale, int roundingMethod) {
try {
return (new BigDecimal
(Double.toString(x))
.setScale(scale, roundingMethod))
.doubleValue();
} catch (NumberFormatException ex) {
if (Double.isInfinite(x)) {
return x;
} else {
return Double.NaN;
}
}
}
这里有一个更好的函数，它可以正确地舍入像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
正如其他人所指出的，正确的答案是使用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
