提供java精确计算类

  1 public class NumberUtils {
  2     
  3     private static final Logger logger = LoggerFactory.getLogger(NumberUtils.class);
  4 
  5     // 缩小倍数
  6     public static final double REDUCE_MULTIPLE_HUNDRED = 100.00000000d;
  7     // 放大倍数
  8     public static final int ZOOM_MULTIPLE_HUNDRED = 100;
  9 
 10     /**
 11      * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精 确的浮点数运算，包括加减乘除和四舍五入。
 12      */
 13     private static final int DEF_DIV_SCALE = 8;
 14 
 15   
 16 
 17     public static Double parseDoubleValue(Double value) {
 18         if (value == null) {
 19             return 0D;
 20         }
 21         return value;
 22     }
 23 
 24 
 25     /**
 26      * 提供精确的加法运算。
 27      * 
 28      * @param v1 被加数
 29      * @param v2 加数
 30      * @return 两个参数的和
 31      */
 32     public static double add(Double v1, Double v2) {
 33         System.out.println("aaaa============================");
 34         logger.info("进来了==============================");
 35         if (v1==null){
 36             v1=0D;
 37         }
 38         if (v2==null){
 39             v2=0D;
 40         }
 41         return v1+v2;
 42     }
 43 
 44     /**
 45      * 提供精确的减法运算。
 46      * 
 47      * @param v1 被减数
 48      * @param v2 减数
 49      * @return 两个参数的差
 50      */
 51     public static double sub(Double v1, Double v2) {
 52         if (v1==null){
 53             v1=0D;
 54         }
 55         if (v2==null){
 56             v2=0D;
 57         }
 58         BigDecimal b1 = BigDecimal.valueOf(v1);
 59         BigDecimal b2 = BigDecimal.valueOf(v2);
 60         return b1.subtract(b2).doubleValue();
 61     }
 62 
 63     public static double sub(Double v1, Double v2, int scale) {
 64         if (v1==null){
 65             v1=0D;
 66         }
 67         if (v2==null){
 68             v2=0D;
 69         }
 70         BigDecimal b1 = BigDecimal.valueOf(v1);
 71         BigDecimal b2 = BigDecimal.valueOf(v2);
 72         return round(b1.subtract(b2).doubleValue(), scale);
 73     }
 74 
 75     /**
 76      * 提供精确的乘法运算。
 77      * 
 78      * @param v1 被乘数
 79      * @param v2 乘数
 80      * @return 两个参数的积
 81      */
 82     public static double mul(Double v1, Double v2) {
 83         if (v1==null){
 84             v1=0D;
 85         }
 86         if (v2==null){
 87             v2=0D;
 88         }
 89         BigDecimal b1 = BigDecimal.valueOf(v1);
 90         BigDecimal b2 = BigDecimal.valueOf(v2);
 91         return b1.multiply(b2).doubleValue();
 92     }
 93 
 94     /**
 95      * 提供精确的乘法运算。
 96      * 
 97      * @param v1 被乘数
 98      * @param v2 乘数
 99      * @return 两个参数的积
100      */
101     public static double mul(Double v1, Double v2, int scale) {
102         if (scale < 0) {
103             throw new IllegalArgumentException("精确度不能小于0。");
104         }
105         if (v1==null){
106             v1=0D;
107         }
108         if (v2==null){
109             v2=0D;
110         }
111         BigDecimal b1 = BigDecimal.valueOf(v1);
112         BigDecimal b2 = BigDecimal.valueOf(v2);
113         return round(b1.multiply(b2).doubleValue(), scale);
114     }
115 
116     /**
117      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后2位，以后的数字四舍五入。
118      * 
119      * @param v1 被除数
120      * @param v2 除数
121      * @return 两个参数的商
122      */
123     public static double div(Double v1, Double v2) {
124         if (v1==null){
125             v1=0D;
126         }
127         if (v2==null || v2==0){
128             throw new IllegalArgumentException("分母不能为空或0。");
129         }
130         return div(v1, v2, DEF_DIV_SCALE);
131     }
132 
133     /**
134      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
135      * 
136      * @param v1 被除数
137      * @param v2 除数
138      * @param scale 表示需要精确到小数点以后几位。
139      * @return 两个参数的商
140      */
141     public static double div(Double v1, Double v2, int scale) {
142         if (scale < 0) {
143             throw new IllegalArgumentException("精确度不能小于0。");
144         }
145         if (v1==null){
146             v1=0D;
147         }
148         if (v2==null){
149             v2=0D;
150         }
151         BigDecimal b1 = BigDecimal.valueOf(v1);
152         BigDecimal b2 = BigDecimal.valueOf(v2);
153         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
154     }
155 
156     /**
157      * 提供精确的小数位四舍五入处理。
158      * 
159      * @param v 需要四舍五入的数字
160      * @param scale 小数点后保留几位
161      * @return 四舍五入后的结果
162      */
163     public static double round(Double v, int scale) {
164         if (scale < 0) {
165             throw new IllegalArgumentException("精确度不能小于0。");
166         }
167         if (v==null){
168             v=0D;
169         }
170         BigDecimal b = BigDecimal.valueOf(v);
171         BigDecimal one = new BigDecimal("1");
172         return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
173     }
174 
175 
176     /**
177      * 提供（相对）精确的计算税额，当发生除不尽的情况时，精确到 小数点以后2位，以后的数字四舍五入。
178      * 
179      * @param amount 本金
180      * @param tax 税率
181      * @return 税额
182      */
183     public static double getTaxAmount(Double amount, double tax) {
184         if (amount==null){
185             amount=0D;
186         }
187         return mul(div(amount, tax + 1), tax, 2);
188     }
189 
190     /**
191      * 获取税金。
192      * 
193      * @param v 需要四舍五入的数字
194      * @param scale 小数点后保留几位
195      * @return 四舍五入后的结果
196      */
197     public static double getTaxAmount(Double amount, Double taxRate, int scale) {
198         if (scale < 0) {
199             throw new IllegalArgumentException("精确度不能小于0。");
200         }
201         if (amount==null){
202             amount=0D;
203         }
204         if (taxRate==null){
205             taxRate=0D;
206         }
207         double taxAmount = mul(NumberUtils.div(amount, NumberUtils.add(1d, taxRate), scale), taxRate, scale);
208         return taxAmount;
209     }
210 }