对BigDecimal常用方法的归类

转自：http://blog.csdn.net/luowen3405/article/details/6249373

BigDecimal.java扩展类：

 

[java] view plaincopy

1. import java.math.BigDecimal;   
2. public class Arith {   
3. /**  
4. * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精  
5. * 确的浮点数运算，包括加减乘除和四舍五入。  
6. */   
7. //默认除法运算精度   
8. private static final int DEF_DIV_SCALE = 10;   
9.       
10. //这个类不能实例化   
11. private Arith(){   
12. }   
13.     /**  
14.      * 提供精确的加法运算。  
15.      * @param v1 被加数  
16.      * @param v2 加数  
17.      * @return 两个参数的和  
18.      */   
19.     public static double add(double v1,double v2){   
20.         BigDecimal b1 = new BigDecimal(Double.toString(v1));   
21.         BigDecimal b2 = new BigDecimal(Double.toString(v2));   
22.         return b1.add(b2).doubleValue();   
23.     }   
24.     /**  
25.      * 提供精确的减法运算。  
26.      * @param v1 被减数  
27.      * @param v2 减数  
28.      * @return 两个参数的差  
29.      */   
30.     public static double sub(double v1,double v2){   
31.         BigDecimal b1 = new BigDecimal(Double.toString(v1));   
32.         BigDecimal b2 = new BigDecimal(Double.toString(v2));   
33.         return b1.subtract(b2).doubleValue();   
34.     }   
35.     /**  
36.      * 提供精确的乘法运算。  
37.      * @param v1 被乘数  
38.      * @param v2 乘数  
39.      * @return 两个参数的积  
40.      */   
41.     public static double mul(double v1,double v2){   
42.         BigDecimal b1 = new BigDecimal(Double.toString(v1));   
43.         BigDecimal b2 = new BigDecimal(Double.toString(v2));   
44.         return b1.multiply(b2).doubleValue();   
45.     }   
46.     /**  
47.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到  
48.      * 小数点以后10位，以后的数字四舍五入。  
49.      * @param v1 被除数  
50.      * @param v2 除数  
51.      * @return 两个参数的商  
52.      */   
53.     public static double div(double v1,double v2){   
54.         return div(v1,v2,DEF_DIV_SCALE);   
55.     }   
56.     /**  
57.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指  
58.      * 定精度，以后的数字四舍五入。  
59.      * @param v1 被除数  
60.      * @param v2 除数  
61.      * @param scale 表示表示需要精确到小数点以后几位。  
62.      * @return 两个参数的商  
63.      */   
64.     public static double div(double v1,double v2,int scale){   
65.         if(scale<0){   
66.             throw new IllegalArgumentException(   
67.                 "The scale must be a positive integer or zero");   
68.         }   
69.         BigDecimal b1 = new BigDecimal(Double.toString(v1));   
70.         BigDecimal b2 = new BigDecimal(Double.toString(v2));   
71.         return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();   
72.     }   
73.     /**  
74.      * 提供精确的小数位四舍五入处理。  
75.      * @param v 需要四舍五入的数字  
76.      * @param scale 小数点后保留几位  
77.      * @return 四舍五入后的结果  
78.      */   
79.     public static double round(double v,int scale){   
80.         if(scale<0){   
81.             throw new IllegalArgumentException(   
82.                 "The scale must be a positive integer or zero");   
83.         }   
84.         BigDecimal b = new BigDecimal(Double.toString(v));   
85.         BigDecimal one = new BigDecimal("1");   
86.         return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();   
87.     }   
88.       
89.    /**  
90.     * 提供精确的类型转换(Float)  
91.     * @param v 需要被转换的数字  
92.     * @return 返回转换结果  
93.     */   
94.     public static float convertsToFloat(double v){   
95.     BigDecimal b = new BigDecimal(v);   
96.     return b.floatValue();   
97.     }   
98.       
99.     /**  
100. * 提供精确的类型转换(Int)不进行四舍五入  
101. * @param v 需要被转换的数字  
102. * @return 返回转换结果  
103. */   
104. public static int convertsToInt(double v){   
105. BigDecimal b = new BigDecimal(v);   
106.     return b.intValue();   
107. }   
108. /**  
109. * 提供精确的类型转换(Long)  
110. * @param v 需要被转换的数字  
111. * @return 返回转换结果  
112. */   
113. public static long convertsToLong(double v){   
114. BigDecimal b = new BigDecimal(v);   
115.     return b.longValue();   
116. }   
117. /**  
118. * 返回两个数中大的一个值  
119. * @param v1 需要被对比的第一个数  
120. * @param v2 需要被对比的第二个数  
121. * @return 返回两个数中大的一个值  
122. */   
123. public static double returnMax(double v1,double v2){   
124. BigDecimal b1 = new BigDecimal(v1);   
125. BigDecimal b2 = new BigDecimal(v2);   
126.     return b1.max(b2).doubleValue();   
127. }   
128. /**  
129. * 返回两个数中小的一个值  
130. * @param v1 需要被对比的第一个数  
131. * @param v2 需要被对比的第二个数  
132. * @return 返回两个数中小的一个值  
133. */   
134. public static double returnMin(double v1,double v2){   
135. BigDecimal b1 = new BigDecimal(v1);   
136. BigDecimal b2 = new BigDecimal(v2);   
137.     return b1.min(b2).doubleValue();   
138. }   
139. /**  
140. * 精确对比两个数字  
141. * @param v1 需要被对比的第一个数  
142. * @param v2 需要被对比的第二个数  
143. * @return 如果两个数一样则返回0，如果第一个数比第二个数大则返回1，反之返回-1  
144. */   
145. public static int compareTo(double v1,double v2){   
146. BigDecimal b1 = new BigDecimal(v1);   
147. BigDecimal b2 = new BigDecimal(v2);   
148.     return b1.compareTo(b2);   
149. }   
150.   
151. }