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 }

提供java精確計算類