Java-精确计算工具类

  1 import java.math.BigDecimal;
  2 import java.math.RoundingMode;
  3 
  4 /**
  5  * 精确计算工具类(加,减,乘,除,返回较大值,返回较小值)
  6  */
  7 public class CalculationUtil {
  8 
  9     /**
 10      * 提供精确加法计算的add方法
 11      */
 12     public static String add(String value1, String value2) {
 13         return add(value1, value2, 0, 0);
 14     }
 15 
 16     /**
 17      * 提供精确加法计算的add方法(默認四捨五入)
 18      * @param value1 被加数
 19      * @param value2 加数
 20      * @param scale 精确范围(小数点后几位)
 21      */
 22     public static String add(String value1, String value2, int scale) {
 23         return add(value1, value2, scale, BigDecimal.ROUND_HALF_UP);
 24     }
 25 
 26     /**
 27      * 提供精确加法计算的add方法
 28      * @param value1 被加数
 29      * @param value2 加数
 30      * @param scale 精确范围(小数点后几位)
 31      * @param roundingMode 精確模式
 32      */
 33     public static String add(String value1, String value2, int scale, int mode) {
 34         BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
 35         BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
 36         BigDecimal result = b1.add(b2);
 37         // mode为0,则不需要精确
 38         if (mode != 0) {
 39             result = result.setScale(scale, mode);
 40         }
 41         return result.toString();
 42     }
 43 
 44     public static int compareTo(String value1, String value2, int scale, int mode) {
 45         BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
 46         BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
 47         BigDecimal result = b1.subtract(b2);
 48         // mode为0,则不需要精确
 49         if (mode != 0) {
 50             result = result.setScale(scale, mode);
 51         }
 52         return result.compareTo(BigDecimal.ZERO);
 53     }
 54 
 55     /**
 56      * 提供精确的除法运算方法divide
 57      * @param value1 被除数
 58      * @param value2 除数
 59      */
 60     public static String divide(String value1, String value2) throws IllegalAccessException {
 61         return divide(value1, value2, 0, null);
 62     }
 63 
 64     /**
 65      * 提供精确的除法运算方法divide(默認四捨五入)
 66      * @param value1 被除数
 67      * @param value2 除数
 68      * @param scale 精确范围(小数点后几位)
 69      */
 70     public static String divide(String value1, String value2, int scale) throws IllegalAccessException {
 71         return divide(value1, value2, scale, RoundingMode.HALF_UP);
 72     }
 73 
 74     /**
 75      * 提供精确的除法运算方法divide
 76      * 
 77      * @param value1 被除数
 78      * @param value2 除数
 79      * @param scale 精确范围(小数点后几位)
 80      * @param roundingMode 精確模式
 81      */
 82     public static String divide(String value1, String value2, int scale, RoundingMode roundingMode)
 83             throws IllegalAccessException {
 84         // 如果精确范围小于0,抛出异常信息
 85         if (scale < 0) {
 86             throw new IllegalAccessException("精确度不能小于0");
 87         }
 88         BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
 89         BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
 90         // roundingMode为null,则不需要精确
 91         if (roundingMode != null) {
 92             return new Double(b1.divide(b2, scale, roundingMode).doubleValue()).toString();
 93         } else {
 94             return new Double(b1.divide(b2).doubleValue()).toString();
 95         }
 96     }
 97 
 98     /**
 99      * 比较大小 :返回较大的那个
100      */
101     public static String getMax(String value1, String value2) {
102         BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
103         BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
104         return new Double(b1.max(b2).doubleValue()).toString();
105     }
106 
107     /**
108      * 比较大小 :返回较小的那个
109      */
110     public static String getMin(String value1, String value2) {
111         BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
112         BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
113         return new Double(b1.min(b2).doubleValue()).toString();
114     }
115 
116 
117     /**
118      *
119      * 提供精确乘法运算的multiply方法
120      * @param value1 被乘数
121      * @param value2 乘数
122      * @return 两个参数的积
123      */
124     public static String multiply(String value1, String value2) {
125         return multiply(value1, value2, 0, 0);
126     }
127 
128     /**
129      * 提供精确乘法运算的multiply方法(默認四捨五入)
130      * @param value1 被乘数
131      * @param value2 乘数
132      * @param scale 精确范围(小数点后几位)
133      */
134     public static String multiply(String value1, String value2, int scale) {
135         return multiply(value1, value2, scale, BigDecimal.ROUND_HALF_UP);
136     }
137 
138     /**
139      * 提供精确乘法运算的multiply方法
140      * @param value1 被乘数
141      * @param value2 乘数
142      * @param scale 精确范围(小数点后几位)
143      * @param roundingMode 精確模式
144      */
145     public static String multiply(String value1, String value2, int scale, int mode) {
146         BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
147         BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
148         BigDecimal result = b1.multiply(b2);
149         // mode为0,则不需要精确
150         if (mode != 0) {
151             result = result.setScale(scale, mode);
152         }
153         return result.toString();
154     }
155 
156     /**
157      * 提供精确减法运算的subtract方法
158      * @param value1 被减数
159      * @param value2 减数
160      * @return 两个参数的差
161      */
162     public static String subtract(String value1, String value2) {
163         return subtract(value1, value2, 0, 0);
164     }
165 
166     /**
167      * 提供精确减法运算的subtract方法(默認四捨五入)
168      * @param value1 被减数
169      * @param value2 减数
170      * @param scale 精确范围(小数点后几位)
171      */
172     public static String subtract(String value1, String value2, int scale) {
173         return subtract(value1, value2, scale, BigDecimal.ROUND_HALF_UP);
174     }
175 
176     /**
177      * 提供精确减法运算的subtract方法
178      * @param value1 被减数
179      * @param value2 减数
180      * @param scale 精确范围(小数点后几位)
181      * @param roundingMode 精確模式
182      */
183     public static String subtract(String value1, String value2, int scale, int mode) {
184         BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
185         BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
186         BigDecimal result = b1.subtract(b2);
187         // mode为0,则不需要精确
188         if (mode != 0) {
189             result = result.setScale(scale, mode);
190         }
191         return result.toString();
192     }
193 }

猜你喜欢

转载自www.cnblogs.com/wang1001/p/9768257.html