Double与BigDecimal 精度问题

转载自：http://superivan.iteye.com/blog/963628

Double与BigDecimal 精度问题

• 博客分类： 
• java

UP 算法 

[1] 精确的浮点运算： 
在Java里面，有时候为了保证数值的准确性需要精确的数据，先提供一个例子就可以发现问题了： 

Java代码  

1. public class FloatNumberTester {  
2.     public static void main(String args[]){  
3.         System.out.println(0.05+0.01);  
4.         System.out.println(1.0 - 0.42);  
5.         System.out.println(4.015 * 100);  
6.         System.out.println(123.3 / 100);  
7.     }  
8. }  

按照我们的期待，上边应该是什么结果呢，但是看输出我们就会发现问题了： 

Java代码  

1. 0.060000000000000005  
2. 0.5800000000000001  
3. 401.49999999999994  
4. 1.2329999999999999  

这样的话这个问题就相对严重了，如果我们使用123.3元交易，计算机却因为1.2329999999999999而拒绝了交易，岂不是和实际情况大相径庭。 

[2] 四舍五入： 
另外的一个计算问题，就是四舍五入。但是Java的计算本身是不能够支持四舍五入的，比如： 

Java代码  

1. public class GetThrowTester {  
2.     public static void main(String args[]){  
3.         System.out.println(4.015 * 100.0);  
4.     }  
5. }  

　 
这个输出为： 
401.49999999999994 
所以就会发现这种情况并不能保证四舍五入，如果要四舍五入，只有一种方法 
java.text.DecimalFormat： 

Java代码  

1. import java.text.DecimalFormat;  
2. public class NumberFormatMain {  
3.     public static void main(String args[]){  
4.         System.out.println(new DecimalFormat("0.00").format(4.025));  
5.         System.out.println(new DecimalFormat("0.00").format(4.024));  
6.     }  
7. }  

上边代码输出为： 

Java代码  

1. 4.02   
2. 4.02   

发现问题了么？因为DecimalFormat使用的舍入模式， 舍入模式 详情参见本文最后部分。 
[3] 浮点输出： 
　　Java浮点类型数值在大于9999999.0就自动转化成为科学计数法，看看下边的例子： 

Java代码  

1.    
2. public class FloatCounter {  
3.     public static void main(String args[]){  
4.         System.out.println(9969999999.04);  
5.         System.out.println(199999999.04);  
6.         System.out.println(1000000011.01);  
7.         System.out.println(9999999.04);  
8.     }  
9. }  

输出结果为： 

Java代码  

1.    
2. 9.96999999904E9   
3. 1.9999999904E8   
4. 1.00000001101E9   
5. 9999999.04  
6.    

但是有时候我们不需要科学计数法，而是转换成为字符串，所以这样可能会有点麻烦。 
总结： 
所以在项目当中，对于浮点类型以及大整数的运算 还是尽量不要用double，long等基本数据类型以及其包装类，还是用Java中提供的BigDecimal，BigInteger等大数值类型来代替吧。 
但这里特别说明一下BigDecimal类的两个构造函数的区别，他们分别是： 
new BigDecimal(String  val ) 和 new BigDecimal(double  val ) 
先看例子： 

Java代码  

1. public class BigDecimalMain {  
2.     public static void main(String args[]){  
3.         System.out.println(new BigDecimal(123456789.01).toString());  
4.         System.out.println(new BigDecimal("123456789.01").toString());  
5.     }  
6. }  

输出结果有一次令人意外了，同时两者之间的区别也一目了然了： 

Java代码  

1. 123456789.01000000536441802978515625   
2. 123456789.01   

所以在 就是想利用double原始类型进行了相关计算之后再转成BigDecimal类型 的场合下，为了防止精度出现偏离，建议使用参数为String类型的该构造方法。即new BigDecimal(String  val )。 


BigDecimal舍入模式介绍： 
　　舍入模式在java.math.RoundingMode 里面： 
RoundingMode.CEILING ：向正无限大方向舍入的舍入模式。如果结果为正，则舍入行为类似于 RoundingMode.UP；如果结果为负，则舍入行为类似于 RoundingMode.DOWN。注意，此舍入模式始终不会减少计算值 
 

输入数字	使用CEILING舍入模式将数字舍入为一位数
5.5	6
2.5	3
1.1	2
1.0	1
-1.0	-1
-1.1	-1
-1.6	-1
-2.5	-2
-5.5	-5

RoundingMode.DOWN ：向零方向舍入的舍入模式。从不对舍弃部分前面的数字加 1（即截尾）。注意，此舍入模式始终不会增加计算值的绝对值 

输入数字	使用DOWN舍入模式将数字舍入为一位数
5.5	5
2.5	2
1.1	1
-1.0	-1
-1.6	-1
-2.5	-2
-5.5	-5

RoundingMode.FLOOR ：向负无限大方向舍入的舍入模式。如果结果为正，则舍入行为类似于 RoundingMode.DOWN；如果结果为负，则舍入行为类似于 RoundingMode.UP。注意，此舍入模式始终不会增加计算值  

输入数字	使用FLOOR舍入模式将输入数字舍入为一位
5.5	5
2.3	2
1.6	1
1.0	1
-1.1	-2
-2.5	-3
-5.5	-6

RoundingMode.HALF_DOWN ：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向下舍入。如果被舍弃部分 > 0.5，则舍入行为同 RoundingMode.UP；否则舍入行为同 RoundingMode.DOWN   

输入数字	使用HALF_DOWN输入模式舍入为一位
5.5	5
2.5	2
1.6	2
1.0	1
-1.1	-1
-1.6	-2
-2.5	-2
-5.5	-5

RoundingMode.HALF_EVEN ：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则舍入行为同 RoundingMode.HALF_UP；如果为偶数，则舍入行为同 RoundingMode.HALF_DOWN。注意，在重复进行一系列计算时，此舍入模式可以在统计上将累加错误减到最小。此舍入模式也称为“银行家舍入法”，主要在美国使用。此舍入模式类似于 Java 中对 float 和 double 算法使用的舍入策略 

输入数字	使用HALF_EVEN舍入模式将输入舍为一位
5.5	6
2.5	2
1.6	2
1.1	1
-1.0	-1
-1.6	-2
-2.5	-2
-5.5	-6

RoundingMode.HALF_UP ：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入。如果被舍弃部分 >= 0.5，则舍入行为同 RoundingMode.UP；否则舍入行为同 RoundingMode.DOWN。注意，此舍入模式就是通常学校里讲的四舍五入  

输入数字	使用HALF_UP舍入模式舍入为一位数
5.5	6
2.5	3
1.6	2
1.0	1
-1.1	-1
-1.6	-2
-2.5	-3
-5.5	-6

RoundingMode.UNNECESSARY ：用于断言请求的操作具有精确结果的舍入模式，因此不需要舍入。如果对生成精确结果的操作指定此舍入模式，则抛出 ArithmeticException 

输入数字	使用UNNECESSARY模式
5.5	抛出 ArithmeticException
2.5	抛出 ArithmeticException
1.6	抛出 ArithmeticException
1.0	1
-1.0	-1.0
-1.1	抛出 ArithmeticException
-1.6	抛出 ArithmeticException
-2.5	抛出 ArithmeticException
-5.5	抛出 ArithmeticException

RoundingMode.UP ：远离零方向舍入的舍入模式。始终对非零舍弃部分前面的数字加 1。注意，此舍入模式始终不会减少计算值的绝对值 

输入数字	使用UP舍入模式将输入数字舍入为一位数
5.5	6
1.6	2
1.1	2
1.0	1
-1.1	-2
-1.6	-2
-2.5	-3
-5.4	-6

Java代码  

1. import  java.math.BigDecimal;   
2. import  java.text.DecimalFormat;   
3. /**  
4.  *使用舍入模式的格式化操作  
5.  **/   
6. public class   DoubleFormat {   
7.     public static void  main(String  args[]){   
8.         DoubleFormat format =  new  DoubleFormat();   
9.         System.out .println(format.doubleOutPut(12.345, 2));   
10.         System.out .println(format.roundNumber(12.335, 2));   
11.     }   
12.     public   String  doubleOutPut(double  v,Integer num){   
13.         if ( v == Double.valueOf(v).intValue()){   
14.             return  Double.valueOf(v).intValue() +  "" ;   
15.         }else {   
16.             BigDecimal b =  new  BigDecimal(Double.toString(v));   
17.             return  b.setScale(num,BigDecimal.ROUND_HALF_UP ).toString();   
18.         }   
19.     }   
20.     public   String  roundNumber(double  v,int  num){   
21.         String  fmtString =  "0000000000000000" ;  //16bit   
22.         fmtString = num>0 ?  "0."   + fmtString.substring(0,num):"0" ;   
23.         DecimalFormat dFormat =  new  DecimalFormat(fmtString);   
24.         return  dFormat.format(v);   
25.     }   
26. }   

　 
　这段代码的输出为： 

Java代码  

1. 12.35   
2. 12.34  
3.