BigDecimal在用double做入参的时候,二进制无法精确地表示十进制小数,编译器读到字符串"0.0000002"和“1.0000002”之后,必须把它转成8个字节的double值,也就是1.0000001999999998947288304407265968620777130126953125类似这种。
所以,运行的时候,实际传给BigDecimal构造函数的真正的数值是1.0000001999999998947288304407265968620777130126953125。
BigDecimal在用String做入参的时候,能够正确地把字符串转化成真正精确的浮点数。
System.out.println部分,如果入参是string,那么直接输出,如果入参是其他类型,那么会调用Object.toString方法进行转化之后进行输出。而Double.toString会使用一定的精度来四舍五入double,然后再输出。
BigDecimal构造方法上的注释就写了这个问题:
The results of this constructor can be somewhat unpredictable.
\* One might assume that writing {@code new BigDecimal(0.1)} in
\* Java creates a {@code BigDecimal} which is exactly equal to
\* 0.1 (an unscaled value of 1, with a scale of 1), but it is
\* actually equal to
\* 0.1000000000000000055511151231257827021181583404541015625.
\* This is because 0.1 cannot be represented exactly as a
\* {@code double} (or, for that matter, as a binary fraction of
\* any finite length). Thus, the value that is being passed
\* *in* to the constructor is not exactly equal to 0.1,
\* appearances notwithstanding.
The {@code String} constructor, on the other hand, is
\* perfectly predictable: writing {@code new BigDecimal("0.1")}
\* creates a {@code BigDecimal} which is *exactly* equal to
\* 0.1, as one would expect. Therefore, it is generally
\* recommended that the {@linkplain #BigDecimal(String)
\* `String` constructor} be used in preference to this one.
补充说明一下:
Double.toString这个方法输出的是一个String,而且会进行四舍五入处理。
new BigDecimal(Double.toString(d1))这个入参在处理完毕之后是一个String,调用的是BigDecimal(String val)这个构造方法。
源码里BigDecimal(String val)这个方法是会将val处理成char[]数组:
this(val.toCharArray(), 0, val.length());
然后调用BigDecimal(char[] in)这个构造方法。
而new BigDecimal(d1)调用的是 BigDecimal(double val),这个方法进来之后第一件事就是
long valBits = Double.doubleToLongBits(val);
把入参转换成二进制,所以会造成精度丢失。
double相加造成的精度丢失和上面的情况一样,先转成bit之后进行计算,然后精度丢失。
double类型数据加减运算时,会出现精度缺失。
打个比方
double number1 = 1;
double number2 = 0.2;
double number3 =number1 + number2 ;
理论上number3会等于1.2;但是在实际的操作过程中会出现1.299999999999这种情况,这就是double类型的数据进行计算时出现精度缺失。
解决方法是使用java.math.BigDecimal进行计算。
/**
* 加法运算
* @param number1
* @param number2
* @return
*/
public static double addDouble(double number1 , double number2) {
BigDecimal bigDecimal1 = new BigDecimal(String.valueOf(number1));
BigDecimal bigDecimal2 = new BigDecimal(String.valueOf(number2));
return bigDecimal1.add(bigDecimal2).doubleValue();
}
/**
* 减法运算
* @param number1
* @param number2
* @return
*/
public static double subDouble(double number1, double number2) {
BigDecimal bigDecimal1 = new BigDecimal(String.valueOf(number1));
BigDecimal bigDecimal2 = new BigDecimal(String.valueOf(number2));
return bigDecimal1.subtract(bigDecimal2).doubleValue();
}
/**
* 乘法运算
* @param number1
* @param number2
* @return
*/
public static double mul(double number1, double number2) {
BigDecimal bigDecimal1 = new BigDecimal(String.valueOf(number1));
BigDecimal bigDecimal2 = new BigDecimal(String.valueOf(number2));
return bigDecimal1.multiply(bigDecimal2).doubleValue();
}
/**
* 除法运算
* @param num
* @param total
* @return
*/
public static BigDecimal divide(double num, double total) {
BigDecimal bigDecimal1 = new BigDecimal(String.valueOf(num));
BigDecimal bigDecimal2 = new BigDecimal(String.valueOf(total));
return bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_HALF_UP);;
}
BigDecimal bd = new BigDecimal("12.1");
long l = bd.setScale( 0, BigDecimal.ROUND_UP ).longValue(); // 向上取整
long l = bd.setScale( 0, BigDecimal.ROUND_DOWN ).longValue(); // 向下取整
* 对于正数而言,ROUND_UP = ROUND_CEILING,ROUND_DOWN = ROUND_FLOOR
各个roundingMode详解如下:
ROUND_UP:非0时,舍弃小数后(整数部分)加1,比如12.49结果为13,-12.49结果为 -13
ROUND_DOWN:直接舍弃小数
ROUND_CEILING:如果 BigDecimal 是正的,则做 ROUND_UP 操作;如果为负,则做 ROUND_DOWN 操作 (一句话:取附近较大的整数)
ROUND_FLOOR: 如果 BigDecimal 是正的,则做 ROUND_DOWN 操作;如果为负,则做 ROUND_UP 操作(一句话:取附近较小的整数)
ROUND_HALF_UP:四舍五入(取更近的整数)
ROUND_HALF_DOWN:跟ROUND_HALF_UP 差别仅在于0.5时会向下取整
ROUND_HALF_EVEN:取最近的偶数
ROUND_UNNECESSARY:不需要取整,如果存在小数位,就抛ArithmeticException 异常
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://lebron.blog.csdn.net/article/details/124923858
内容来源于网络,如有侵权,请联系作者删除!