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 }
原文地址：https://www.cnblogs.com/nutural/p/11373751.html
时间： 2024-10-23 04:19:34