我想要的是一种将双精度转换为字符串的方法，该字符串使用半向上舍入方法进行舍入-即，如果要舍入的小数为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中实现这一点的最佳方法是什么？
public static double formatDecimal(double amount) {
BigDecimal amt = new BigDecimal(amount);
amt = amt.divide(new BigDecimal(1), 2, BigDecimal.ROUND_HALF_EVEN);
return amt.doubleValue();
}
使用Junit进行测试
@RunWith(Parameterized.class)
public class DecimalValueParameterizedTest {
@Parameterized.Parameter
public double amount;
@Parameterized.Parameter(1)
public double expectedValue;
@Parameterized.Parameters
public static List<Object[]> dataSets() {
return Arrays.asList(new Object[][]{
{1000.0, 1000.0},
{1000, 1000.0},
{1000.00000, 1000.0},
{1000.01, 1000.01},
{1000.1, 1000.10},
{1000.001, 1000.0},
{1000.005, 1000.0},
{1000.007, 1000.01},
{1000.999, 1001.0},
{1000.111, 1000.11}
});
}
@Test
public void testDecimalFormat() {
Assert.assertEquals(expectedValue, formatDecimal(amount), 0.00);
}
因此，在阅读了大部分答案后，我意识到其中大多数答案都不精确，事实上，使用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的预期产量。
Real的Java How to发布了这个解决方案，它也与Java 1.6之前的版本兼容。
BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();
UPDATE:BigDecimal.ROUND_HALF_UP已弃用-使用舍入模式
BigDecimal bd = new BigDecimal(Double.toString(number));
bd = bd.setScale(decimalPlaces, RoundingMode.HALF_UP);
return bd.doubleValue();
由于我找不到关于这个主题的完整答案，我已经组建了一个类，该类应该正确处理这个问题，并支持：
格式化：轻松将双精度字符串格式化为具有一定小数位数的字符串解析：将格式化值解析回double区域设置：使用默认区域设置格式化和解析指数表示法：在某个阈值之后开始使用指数表示法
用法很简单：
（对于本示例，我使用的是自定义区域设置）
public static final int DECIMAL_PLACES = 2;
NumberFormatter formatter = new NumberFormatter(DECIMAL_PLACES);
String value = formatter.format(9.319); // "9,32"
String value2 = formatter.format(0.0000005); // "5,00E-7"
String value3 = formatter.format(1324134123); // "1,32E9"
double parsedValue1 = formatter.parse("0,4E-2", 0); // 0.004
double parsedValue2 = formatter.parse("0,002", 0); // 0.002
double parsedValue3 = formatter.parse("3423,12345", 0); // 3423.12345
这是课程：
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.ParseException;
import java.util.Locale;
public class NumberFormatter {
private static final String SYMBOL_INFINITE = "\u221e";
private static final char SYMBOL_MINUS = '-';
private static final char SYMBOL_ZERO = '0';
private static final int DECIMAL_LEADING_GROUPS = 10;
private static final int EXPONENTIAL_INT_THRESHOLD = 1000000000; // After this value switch to exponential notation
private static final double EXPONENTIAL_DEC_THRESHOLD = 0.0001; // Below this value switch to exponential notation
private DecimalFormat decimalFormat;
private DecimalFormat decimalFormatLong;
private DecimalFormat exponentialFormat;
private char groupSeparator;
public NumberFormatter(int decimalPlaces) {
configureDecimalPlaces(decimalPlaces);
}
public void configureDecimalPlaces(int decimalPlaces) {
if (decimalPlaces <= 0) {
throw new IllegalArgumentException("Invalid decimal places");
}
DecimalFormatSymbols separators = new DecimalFormatSymbols(Locale.getDefault());
separators.setMinusSign(SYMBOL_MINUS);
separators.setZeroDigit(SYMBOL_ZERO);
groupSeparator = separators.getGroupingSeparator();
StringBuilder decimal = new StringBuilder();
StringBuilder exponential = new StringBuilder("0.");
for (int i = 0; i < DECIMAL_LEADING_GROUPS; i++) {
decimal.append("###").append(i == DECIMAL_LEADING_GROUPS - 1 ? "." : ",");
}
for (int i = 0; i < decimalPlaces; i++) {
decimal.append("#");
exponential.append("0");
}
exponential.append("E0");
decimalFormat = new DecimalFormat(decimal.toString(), separators);
decimalFormatLong = new DecimalFormat(decimal.append("####").toString(), separators);
exponentialFormat = new DecimalFormat(exponential.toString(), separators);
decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
decimalFormatLong.setRoundingMode(RoundingMode.HALF_UP);
exponentialFormat.setRoundingMode(RoundingMode.HALF_UP);
}
public String format(double value) {
String result;
if (Double.isNaN(value)) {
result = "";
} else if (Double.isInfinite(value)) {
result = String.valueOf(SYMBOL_INFINITE);
} else {
double absValue = Math.abs(value);
if (absValue >= 1) {
if (absValue >= EXPONENTIAL_INT_THRESHOLD) {
value = Math.floor(value);
result = exponentialFormat.format(value);
} else {
result = decimalFormat.format(value);
}
} else if (absValue < 1 && absValue > 0) {
if (absValue >= EXPONENTIAL_DEC_THRESHOLD) {
result = decimalFormat.format(value);
if (result.equalsIgnoreCase("0")) {
result = decimalFormatLong.format(value);
}
} else {
result = exponentialFormat.format(value);
}
} else {
result = "0";
}
}
return result;
}
public String formatWithoutGroupSeparators(double value) {
return removeGroupSeparators(format(value));
}
public double parse(String value, double defValue) {
try {
return decimalFormat.parse(value).doubleValue();
} catch (ParseException e) {
e.printStackTrace();
}
return defValue;
}
private String removeGroupSeparators(String number) {
return number.replace(String.valueOf(groupSeparator), "");
}
}
