java常用类之BigDecimal
bigdecimal
小数计算丢失精度问题
在计算机中,所有文件都是以二进制存储的,数字运算也是使用二进制进行计算的,因为计算机中不存在小数点,所以我们通常说的浮点数如float
、double
都是计算机使用二进制模拟出来的,但我们在计算机中运行以下代码获得的结果并不是正确的。
double a = 0.1; double b = 0.3; system.out.println(b-a); // 结果为0.19999999999999998
为什么呢?
我们先来看十进制小数如何转化为二进制数的
二进制小数 0.1111
第一位1表示十进制1/2 第二位1表示十进制1/4 第三位1表示十进制1/8 第四位1表示十进制1/16 ......
所以十进制小数转二进制小数,算法是乘以2直到没有了小数为止。举个例子,0.9表示成二进制数
0.9*2=1.8 取整数部分 1 0.8(1.8的小数部分)*2=1.6 取整数部分 1 0.6*2=1.2 取整数部分 1 0.2*2=0.4 取整数部分 0 0.4*2=0.8 取整数部分 0 0.8*2=1.6 取整数部分 1 0.6*2=1.2 取整数部分 0 ......... 0.9二进制表示为(从上往下): 1100100100100......
注意:上面的计算过程循环了,也就是说*2永远不可能消灭小数部分,这样算法将无限下去。很显然,小数的二进制表示有时是不可能精确的 。其实道理很简单,十进制系统中能不能准确表示出1/3呢?同样二进制系统也无法准确表示1/10。这也就解释了为什么浮点型减法出现了"减不尽"的精度丢失问题。
bigdecimal简介
因为丢失精度问题,所以java引入了bigdecimal类来解决这一问题。
bigdecimal 由任意精度的整数非标度值 和32 位的整数标度 (scale) 组成。如果为零或正数,则标度是小数点后的位数。如果为负数,则将该数的非标度值乘以 10 的负scale 次幂。因此,bigdecimal表示的数值是(unscaledvalue × 10-scale)。
bigdecimal函数介绍
构造函数
构造函数如下
我们使用参数为double
的构造方法创建对象,并打印输出代码如下
bigdecimal b1 =new bigdecimal(0.1); system.out.println(b1); //结果为0.1000000000000000055511151231257827021181583404541015625
我们期望的结果为0.1,可是结果还是损失精度的。难道bigdecimal没用吗?
使用下面方式声明bigdecimal时,会出现精度问题
bigdecimal b = new bigdecimal(0.1);
推荐用法
bigdecimal bd1 = new bigdecimal("0.1"); bigdecimal bd2 = bigdecimal.valueof(0.1);
用以上方法就不会出问题精度问题
bigdecimal.valueof() 查看源码就可以知道,也是使用的new bigdecimal("0.1")构造函数
jdk的描述:1、参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在java中写入new bigdecimal(0.1)所创建的bigdecimal正好等于 0.1(非标度值 1,其标度为 1),但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double(或者说对于该情况,不能表示为任何有限长度的二进制小数)。这样,传入到构造方法的值不会正好等于 0.1(虽然表面上等于该值)。
2、另一方面,string 构造方法是完全可预知的:写入 newbigdecimal("0.1") 将创建一个 bigdecimal,它正好等于预期的 0.1。因此,比较而言,通常建议优先使用string构造方法。
3、当double必须用作bigdecimal的源时,请注意,此构造方法提供了一个准确转换;它不提供与以下操作相同的结果:先使用double.tostring(double)方法,然后使用bigdecimal(string)构造方法,将double转换为string。要获取该结果,请使用static valueof(double)方法。
常用方法
- 1.bigdecimal(string val):构造方法,将string类型转换成bigdecimal类型数据。
- 2.bigdecimal(double val):构造方法,将double类型转换成bigdecimal类型数据。
- 3.bigdecimal(int val):构造方法,将int类型转换成bigdecimal类型数据。
- 4.bigdecimal add(bigdecimal value):加法,求两个bigdecimal类型数据的和。
- 5.bigdecimal subtract(bigdecimal value):减法,求两个bigdecimal类型数据的差。
- 6.bigdecimal multiply(bigdecimal value):乘法,求两个bigdecimal类型数据的积。
- 7.bigdecimal divide(bigdecimal divisor):除法,求两个bigdecimal类型数据的商。
- 8.bigdecimal remainder(bigdecimal divisor):求余数,求bigdecimal类型数据除以divisor的余数。
- 9.bigdecimal max(bigdecimal value):最大数,求两个bigdecimal类型数据的最大值。
- 10.bigdecimal min(bigdecimal value):最小数,求两个bigdecimal类型数据的最小值。
- 11.bigdecimal abs():绝对值,求bigdecimal类型数据的绝对值。
- 12.bigdecimal negate():相反数,求bigdecimal类型数据的相反数。
代码演示
bigdecimal a=new bigdecimal ("4.5"); bigdecimal b=new bigdecimal ("1.5"); bigdecimal c=new bigdecimal ("-10.5"); bigdecimal add_result=a.add(b); bigdecimal subtract_result=a.subtract(b); bigdecimal multiply_result=a.multiply(b); bigdecimal divide_result=a.divide(b); bigdecimal remainder_result=a.remainder(b); bigdecimal max_result=a.max(b); bigdecimal min_result=a.min(b); bigdecimal abs_result=c.abs(); bigdecimal negate_result=a.negate(); log.d("tag","4.5+1.5="+add_result); log.d("tag","4.5-1.5="+subtract_result); log.d("tag","4.5*1.5="+multiply_result); log.d("tag","4.5/1.5="+divide_result); log.d("tag","4.5/1.5余数="+remainder_result); log.d("tag","4.5和1.5最大数="+max_result); log.d("tag","4.5和1.5最小数="+min_result); log.d("tag","-10.5的绝对值="+abs_result); log.d("tag","4.5的相反数="+negate_result);
结果为
4.5+1.5=6.0 4.5-1.5=3.0 4.5*1.5=6.75 4.5/1.5=3 4.5/1.5余数=0.0 4.5和1.5最大数=4.5 4.5和1.5最小数=1.5 -10.5的绝对值=10.5 4.5的相反数=-4.5
bigdecimal都是不可变的(immutable)的,在进行每一步运算时,都会产生一个新的对象,所以在做加减乘除运算时千万要保存操作后的值。
bigdecimal
用scale()
表示小数位数,例如:
bigdecimal d1 = new bigdecimal("123.45"); bigdecimal d2 = new bigdecimal("123.4500"); bigdecimal d3 = new bigdecimal("1234500"); system.out.println(d1.scale()); // 2,两位小数 system.out.println(d2.scale()); // 4 system.out.println(d3.scale()); // 0
通过bigdecimal
的striptrailingzeros()
方法,可以将一个bigdecimal
格式化为一个相等的,但去掉了末尾0的bigdecimal
:
bigdecimal d1 = new bigdecimal("123.4500"); bigdecimal d2 = d1.striptrailingzeros(); system.out.println(d1.scale()); // 4 system.out.println(d2.scale()); // 2,因为去掉了00 bigdecimal d3 = new bigdecimal("1234500"); bigdecimal d4 = d1.striptrailingzeros(); system.out.println(d3.scale()); // 0 system.out.println(d4.scale()); // -2
如果一个bigdecimal
的scale()
返回负数,例如,-2,表示这个数是个整数,并且末尾有2个0。
可以对一个bigdecimal
设置它的scale
,如果精度比原始值低,那么按照指定的方法进行四舍五入或者直接截断:
public class main { public static void main(string[] args) { bigdecimal d1 = new bigdecimal("123.456789"); bigdecimal d2 = d1.setscale(4, roundingmode.half_up); // 四舍五入,123.4568 bigdecimal d3 = d1.setscale(4, roundingmode.down); // 直接截断,123.4567 system.out.println(d2); system.out.println(d3); } }
对bigdecimal
做加、减、乘时,精度不会丢失,但是做除法时,存在无法除尽的情况,这时,就必须指定精度以及如何进行截断:
bigdecimal d1 = new bigdecimal("123.456"); bigdecimal d2 = new bigdecimal("23.456789"); bigdecimal d3 = d1.divide(d2, 10, roundingmode.half_up); // 保留10位小数并四舍五入
在比较两个bigdecimal
的值是否相等时,要特别注意,使用equals()
方法不但要求两个bigdecimal
的值相等,还要求它们的scale()
相等:
bigdecimal d1 = new bigdecimal("123.456"); bigdecimal d2 = new bigdecimal("123.45600"); system.out.println(d1.equals(d2)); // false,因为scale不同 system.out.println(d1.equals(d2.striptrailingzeros())); // true,因为d2去除尾部0后scale变为2 system.out.println(d1.compareto(d2)); // 0
必须使用compareto()
方法来比较,它根据两个值的大小分别返回负数、正数和0,分别表示小于、大于和等于。
总是使用compareto()
比较两个bigdecimal
的值,不要使用equals()
!
如果查看bigdecimal
的源码,可以发现,实际上一个bigdecimal
是通过一个biginteger
和一个scale
来表示的,即biginteger
表示一个完整的整数,而scale
表示小数位数:
public class bigdecimal extends number implements comparable<bigdecimal> { private final biginteger intval; private final int scale; }
bigdecimal
也是从number
继承的,也是不可变对象。
源码分析
为什么bigdecimal
使用string
不会出现精度问题
现在我们明白为什么用double
,floa
t 出现出精度问题。现在我们要看一下bigdecimal
对string做了什么不会出现精度问题
通过debug构造方法,我们可以了解,bigdecimal底层数据结构主要是由下面四个属性值组成.
int scale; //有多少位小数(即小数点后有多少位) int precision; //总工有多少位数字 long intcompact; //字符串去掉小数点后,转为long的值,只有当传的字符串长度小于18时才使用该言 biginteger intval; //当传的字符串长度大于等于18时才使用biginteger表示数字
以new bigdecimal("12.12")
为例
scale值为2 precision值为4 intcompact值为1212 intval值为空。 之所以为空是因为字符串长度没有超18位,所以不启用biginteger表示
看到这进而其实大家应该明白了,bigdecimal将string转为了long或biginteger来进行计算。
valueof(doubleval)方法
valueof
实际上是调用相应包装类的tostring
方法然后使用bigdecimal的参数为string的构造方法创建对象。
add(bigdecimal augend)方法
public bigdecimal add(bigdecimal augend) { long xs = this.intcompact; //整型数字表示的bigdecimal,例a的intcompact值为122 long ys = augend.intcompact;//同上 biginteger fst = (this.intcompact != inflated) ? null : this.intval;//初始化biginteger的值,intval为bigdecimal的一个biginteger类型的属性 biginteger snd = (augend.intcompact != inflated) ? null : augend.intval; int rscale = this.scale;//小数位数 long sdiff = (long) rscale - augend.scale;//小数位数之差 if (sdiff != 0) {//取小数位数多的为结果的小数位数 if (sdiff < 0) { int raise = checkscale(-sdiff); rscale = augend.scale; if (xs == inflated || (xs = longmultiplypowerten(xs, raise)) == inflated) fst = bigmultiplypowerten(raise); } else { int raise = augend.checkscale(sdiff); if (ys == inflated || (ys = longmultiplypowerten(ys, raise)) == inflated) snd = augend.bigmultiplypowerten(raise); } } if (xs != inflated && ys != inflated) { long sum = xs + ys; if ((((sum ^ xs) & (sum ^ ys))) >= 0l)//判断有无溢出 return bigdecimal.valueof(sum, rscale);//返回使用bigdecimal的静态工厂方法得到的bigdecimal实例 } if (fst == null) fst = biginteger.valueof(xs);//biginteger的静态工厂方法 if (snd == null) snd = biginteger.valueof(ys); biginteger sum = fst.add(snd); return (fst.signum == snd.signum) ? new bigdecimal(sum, inflated, rscale, 0) : new bigdecimal(sum, compactvalfor(sum), rscale, 0);//返回通过其他构造方法得到的bigdecimal对象 }
以上只是对加法源码的分析,减乘除其实最终都返回的是一个新的bigdecimal对象,因为biginteger与bigdecimal都是不可变的(immutable)的,在进行每一步运算时,都会产生一个新的对象,所以a.add(b);虽然做了加法操作,但是a并没有保存加操作后的值,正确的用法应该是a=a.add(b);
总结
(1)商业计算使用bigdecimal。
(2)尽量使用参数类型为string的构造函数。
(3) bigdecimal都是不可变的(immutable)的,在进行每一步运算时,都会产生一个新的对象,所以在做加减乘除运算时千万要保存操作后的值。
(4)我们往往容易忽略jdk底层的一些实现细节,导致出现错误,需要多加注意。
参考内容:
,
,
。
上一篇: Android 使用URLConnection下载音频文件
下一篇: Django-视图函数view