JAVA简单精确计算工具类

  1 public class ArithUtil {
  2 
  3     // 默认除法运算精度
  4     private static final int DEF_DIV_SCALE = 10;
  5 
  6     private ArithUtil() {
  7         
  8     }
  9 
 10     /**
 11      * 提供精确的加法运算。
 12      * 
 13      * @param v1
 14      *            被加数
 15      * @param v2
 16      *            加数
 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     public static double add(double v1, double v2,int scale) {
 26         BigDecimal b1 = new BigDecimal(Double.toString(v1)).setScale(scale, BigDecimal.ROUND_HALF_DOWN);
 27         BigDecimal b2 = new BigDecimal(Double.toString(v2)).setScale(scale, BigDecimal.ROUND_HALF_DOWN);
 28         return b1.add(b2).doubleValue();
 29     }
 30     /**
 31      * 提供精确的减法运算。
 32      * 
 33      * @param v1
 34      *            被减数
 35      * @param v2
 36      *            减数
 37      * @return 两个参数的差
 38      */
 39     public static double sub(double v1, double v2) {
 40         BigDecimal b1 = new BigDecimal(Double.toString(v1));
 41         BigDecimal b2 = new BigDecimal(Double.toString(v2));
 42         return b1.subtract(b2).doubleValue();
 43     }
 44 
 45     public static double sub(double v1, double v2,int scale) {
 46         BigDecimal b1 = new BigDecimal(Double.toString(v1)).setScale(scale, BigDecimal.ROUND_HALF_DOWN);
 47         BigDecimal b2 = new BigDecimal(Double.toString(v2)).setScale(scale, BigDecimal.ROUND_HALF_DOWN);
 48         return b1.subtract(b2).doubleValue();
 49     }
 50     /**
 51      * 提供精确的乘法运算。
 52      * 
 53      * @param v1
 54      *            被乘数
 55      * @param v2
 56      *            乘数
 57      * @return 两个参数的积
 58      */
 59     public static double mul(double v1, double v2) {
 60         BigDecimal b1 = new BigDecimal(Double.toString(v1));
 61         BigDecimal b2 = new BigDecimal(Double.toString(v2));
 62         return b1.multiply(b2).doubleValue();
 63     }
 64 
 65     /**
 66      * 提供精确的乘法运算。
 67      * 
 68      * @param v1
 69      *            被乘数
 70      * @param v2
 71      *            乘数
 72      * @return 两个参数的积
 73      */
 74     public static double mul(double v1, double v2,int scale) {
 75         BigDecimal b1 = new BigDecimal(Double.toString(v1));
 76         BigDecimal b2 = new BigDecimal(Double.toString(v2));
 77         return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_DOWN).doubleValue();
 78     }
 79     /**
 80      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。
 81      * 
 82      * @param v1
 83      *            被除数
 84      * @param v2
 85      *            除数
 86      * @return 两个参数的商
 87      */
 88     public static double div(double v1, double v2) {
 89         return div(v1, v2, DEF_DIV_SCALE);
 90     }
 91 
 92     /**
 93      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
 94      * 
 95      * @param v1
 96      *            被除数
 97      * @param v2
 98      *            除数
 99      * @param scale
100      *            表示表示需要精确到小数点以后几位。
101      * @return 两个参数的商
102      */
103     public static double div(double v1, double v2, int scale) {
104         if (scale < 0) {
105             throw new IllegalArgumentException("参数scale必须为整数为零!");
106         }
107         BigDecimal b1 = new BigDecimal(Double.toString(v1));
108         BigDecimal b2 = new BigDecimal(Double.toString(v2));
109         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
110     }
111 
112     /**
113      * 提供精确的小数位四舍五入处理。
114      * 
115      * @param v
116      *            需要四舍五入的数字
117      * @param scale
118      *            小数点后保留几位
119      * @return 四舍五入后的结果
120      */
121     public static double round(double v, int scale) {
122         if (scale < 0) {
123             throw new IllegalArgumentException("参数scale必须为整数为零!");
124         }
125         BigDecimal b = new BigDecimal(Double.toString(v));
126         BigDecimal one = new BigDecimal("1");
127         return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
128     }
129 
130     /**
131      * 提供精确的类型转换(Float)
132      * 
133      * @param v
134      *            需要被转换的数字
135      * @return 返回转换结果
136      */
137     public static float convertsToFloat(double v) {
138         BigDecimal b = new BigDecimal(v);
139         return b.floatValue();
140     }
141 
142     /**
143      * 提供精确的类型转换(Int)不进行四舍五入
144      * 
145      * @param v
146      *            需要被转换的数字
147      * @return 返回转换结果
148      */
149     public static int convertsToInt(double v) {
150         BigDecimal b = new BigDecimal(v);
151         return b.intValue();
152     }
153 
154     /**
155      * 提供精确的类型转换(Long)
156      * 
157      * @param v
158      *            需要被转换的数字
159      * @return 返回转换结果
160      */
161     public static long convertsToLong(double v) {
162         BigDecimal b = new BigDecimal(v);
163         return b.longValue();
164     }
165 
166     /**
167      * 返回两个数中大的一个值
168      * 
169      * @param v1
170      *            需要被对比的第一个数
171      * @param v2
172      *            需要被对比的第二个数
173      * @return 返回两个数中大的一个值
174      */
175     public static double returnMax(double v1, double v2) {
176         BigDecimal b1 = new BigDecimal(v1);
177         BigDecimal b2 = new BigDecimal(v2);
178         return b1.max(b2).doubleValue();
179     }
180 
181     /**
182      * 返回两个数中小的一个值
183      * 
184      * @param v1
185      *            需要被对比的第一个数
186      * @param v2
187      *            需要被对比的第二个数
188      * @return 返回两个数中小的一个值
189      */
190     public static double returnMin(double v1, double v2) {
191         BigDecimal b1 = new BigDecimal(v1);
192         BigDecimal b2 = new BigDecimal(v2);
193         return b1.min(b2).doubleValue();
194     }
195 
196     /**
197      * 精确比较两个数字
198      * 
199      * @param v1
200      *            需要被对比的第一个数
201      * @param v2
202      *            需要被对比的第二个数
203      * @return 如果两个数一样则返回0，如果第一个数比第二个数大则返回1，反之返回-1
204      */
205     public static int compareTo(double v1, double v2) {
206         BigDecimal b1 = new BigDecimal(v1);
207         BigDecimal b2 = new BigDecimal(v2);
208         return b1.compareTo(b2);
209     }
210     
211     /**
212      * 获取数字小数位数
213      * 
214      * @param number
215      *            数字.
216      * 
217      * @return 小数位数
218      */
219     public static int getDecimals(double number) {
220         DecimalFormat decimalFormat = new DecimalFormat("#.####");
221         String numberString = decimalFormat.format(number);
222         if (numberString.indexOf(".") > 0) {
223             return numberString.length() - String.valueOf(number).indexOf(".") - 1;
224         } else {
225             return 0;
226         }
227     }
228     
229     /**
230      * 获取数字小数位数
231      * 
232      * @param number
233      *            数字.
234      * 
235      * @return 小数位数
236      */
237     public static int getDecimals(float number) {
238         DecimalFormat decimalFormat = new DecimalFormat("#.####");
239         String numberString = decimalFormat.format(number);
240         if (numberString.indexOf(".") > 0) {
241             return numberString.length() - String.valueOf(number).indexOf(".") - 1;
242         } else {
243             return 0;
244         }
245     }
246 }