java中Double数值的计算

1. /** 
2.  * double的计算不精确，会有类似0.0000000000000002的误差，正确的方法是使用BigDecimal或者用整型 
3.  整型地方法适合于货币精度已知的情况，比如12.11+1.10转成1211+110计算，最后再/100即可 
4.  以下是摘抄的BigDecimal方法: 
5.  */  
6. import java.io.Serializable;  
7. import java.math.BigDecimal;  
8. import org.springframework.stereotype.Component;  
9.   
10. @Component  
11. public class DoubleUtil implements Serializable {  
12.     private static final long serialVersionUID = -3345205828566485102L;  
13.     // 默认除法运算精度  
14.     private static final Integer DEF_DIV_SCALE = 2;  
15.   
16.     /** 
17.      * 提供精确的加法运算。 
18.      * @param value1 被加数 
19.      * @param value2 加数 
20.      * @return 两个参数的和 
21.      */  
22.     public Double add(Number value1, Number value2) {  
23.         BigDecimal b1 = new BigDecimal(Double.toString(value1.doubleValue()));  
24.         BigDecimal b2 = new BigDecimal(Double.toString(value2.doubleValue()));  
25.         return b1.add(b2).doubleValue();  
26.     }  
27.   
28.     /** 
29.      * 提供精确的减法运算。 
30.      *  
31.      * @param value1 
32.      *            被减数 
33.      * @param value2 
34.      *            减数 
35.      * @return 两个参数的差 
36.      */  
37.     public double sub(Number value1, Number value2) {  
38.         BigDecimal b1 = new BigDecimal(Double.toString(value1.doubleValue()));  
39.         BigDecimal b2 = new BigDecimal(Double.toString(value2.doubleValue()));  
40.         return b1.subtract(b2).doubleValue();  
41.     }  
42.   
43.     /** 
44.      * 提供精确的乘法运算。 
45.      *  
46.      * @param value1 
47.      *            被乘数 
48.      * @param value2 
49.      *            乘数 
50.      * @return 两个参数的积 
51.      */  
52.     public Double mul(Number value1, Number value2) {  
53.         BigDecimal b1 = new BigDecimal(Double.toString(value1.doubleValue()));  
54.         BigDecimal b2 = new BigDecimal(Double.toString(value2.doubleValue()));  
55.         return b1.multiply(b2).doubleValue();  
56.     }  
57.   
58.     /** 
59.      * 提供（相对）精确的除法运算，当发生除不尽的情况时， 精确到小数点以后10位，以后的数字四舍五入。 
60.      *  
61.      * @param dividend 
62.      *            被除数 
63.      * @param divisor 
64.      *            除数 
65.      * @return 两个参数的商 
66.      */  
67.     public Double div(Double dividend, Double divisor) {  
68.         return div(dividend, divisor, DEF_DIV_SCALE);  
69.     }  
70.   
71.     /** 
72.      * 提供（相对）精确的除法运算。 当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。 
73.      *  
74.      * @param dividend 
75.      *            被除数 
76.      * @param divisor 
77.      *            除数 
78.      * @param scale 
79.      *            表示表示需要精确到小数点以后几位。 
80.      * @return 两个参数的商 
81.      */  
82.     public Double div(Double dividend, Double divisor, Integer scale) {  
83.         if (scale < 0) {  
84.             throw new IllegalArgumentException(  
85.                     "The scale must be a positive integer or zero");  
86.         }  
87.         BigDecimal b1 = new BigDecimal(Double.toString(dividend));  
88.         BigDecimal b2 = new BigDecimal(Double.toString(divisor));  
89.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();  
90.     }  
91.   
92.     /** 
93.      * 提供精确的小数位四舍五入处理。 
94.      *  
95.      * @param value 
96.      *            需要四舍五入的数字 
97.      * @param scale 
98.      *            小数点后保留几位 
99.      * @return 四舍五入后的结果 
100.      */  
101.     public Double round(Double value, Integer scale) {  
102.         if (scale < 0) {  
103.             throw new IllegalArgumentException(  
104.                     "The scale must be a positive integer or zero");  
105.         }  
106.         BigDecimal b = new BigDecimal(Double.toString(value));  
107.         BigDecimal one = new BigDecimal("1");  
108.         return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();  
109.     }  
110. }