1
import java.math.BigDecimal;
2
import java.math.RoundingMode;
3

4
/**
5
 * 简化BigDecimal计算的小工具类
6
 */
7
public class BigDecimalUtil {
8

9
    /**
10
     * 默认除法运算精度
11
     */
12
    private static final int DEF_DIV_SCALE = 10;
13

14
    private BigDecimalUtil() {
15
    }
16

17
    /**
18
     * 提供精确的加法运算。
19
     *
20
     * @param v1 被加数
21
     * @param v2 加数
22
     * @return 两个参数的和
23
     */
24
    public static double add(double v1, double v2) {
25
        BigDecimal b1 = BigDecimal.valueOf(v1);
26
        BigDecimal b2 = BigDecimal.valueOf(v2);
27
        return b1.add(b2).doubleValue();
28
    }
29

30
    /**
31
     * 提供精确的减法运算。
32
     *
33
     * @param v1 被减数
34
     * @param v2 减数
35
     * @return 两个参数的差
36
     */
37
    public static double subtract(double v1, double v2) {
38
        BigDecimal b1 = BigDecimal.valueOf(v1);
39
        BigDecimal b2 = BigDecimal.valueOf(v2);
40
        return b1.subtract(b2).doubleValue();
41
    }
42

43
    /**
44
     * 提供精确的乘法运算。
45
     *
46
     * @param v1 被乘数
47
     * @param v2 乘数
48
     * @return 两个参数的积
49
     */
50
    public static double multiply(double v1, double v2) {
51
        BigDecimal b1 = BigDecimal.valueOf(v1);
52
        BigDecimal b2 = BigDecimal.valueOf(v2);
53
        return b1.multiply(b2).doubleValue();
54
    }
55

56
    /**
57
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
58
     * 小数点以后10位，以后的数字四舍六入五成双。
59
     *
60
     * @param v1 被除数
61
     * @param v2 除数
62
     * @return 两个参数的商
63
     */
64
    public static double divide(double v1, double v2) {
65
        return divide(v1, v2, DEF_DIV_SCALE);
66
    }
67

68
    /**
69
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
70
     * 定精度，以后的数字四舍六入五成双。
71
     *
72
     * @param v1    被除数
73
     * @param v2    除数
74
     * @param scale 表示表示需要精确到小数点以后几位。
75
     * @return 两个参数的商
76
     */
77
    public static double divide(double v1, double v2, int scale) {
78
        if (scale < 0) {
79
            throw new IllegalArgumentException(
80
                    "The scale must be a positive integer or zero");
81
        }
82
        BigDecimal b1 = BigDecimal.valueOf(v1);
83
        BigDecimal b2 = BigDecimal.valueOf(v2);
84
        return b1.divide(b2, scale, RoundingMode.HALF_EVEN).doubleValue();
85
    }
86

87
    /**
88
     * 提供精确的小数位四舍六入五成双处理。
89
     *
90
     * @param v     需要四舍六入五成双的数字
91
     * @param scale 小数点后保留几位
92
     * @return 四舍六入五成双后的结果
93
     */
94
    public static double round(double v, int scale) {
95
        if (scale < 0) {
96
            throw new IllegalArgumentException(
97
                    "The scale must be a positive integer or zero");
98
        }
99
        BigDecimal b = BigDecimal.valueOf(v);
100
        BigDecimal one = new BigDecimal("1");
101
        return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
102
    }
103

104
    /**
105
     * 提供精确的类型转换(Float)
106
     *
107
     * @param v 需要被转换的数字
108
     * @return 返回转换结果
109
     */
110
    public static float convertToFloat(double v) {
111
        BigDecimal b = new BigDecimal(v);
112
        return b.floatValue();
113
    }
114

115
    /**
116
     * 提供精确的类型转换(Int)不进行四舍六入五成双
117
     *
118
     * @param v 需要被转换的数字
119
     * @return 返回转换结果
120
     */
121
    public static int convertsToInt(double v) {
122
        BigDecimal b = new BigDecimal(v);
123
        return b.intValue();
124
    }
125

126
    /**
127
     * 提供精确的类型转换(Long)
128
     *
129
     * @param v 需要被转换的数字
130
     * @return 返回转换结果
131
     */
132
    public static long convertsToLong(double v) {
133
        BigDecimal b = new BigDecimal(v);
134
        return b.longValue();
135
    }
136

137
    /**
138
     * 返回两个数中大的一个值
139
     *
140
     * @param v1 需要被对比的第一个数
141
     * @param v2 需要被对比的第二个数
142
     * @return 返回两个数中大的一个值
143
     */
144
    public static double returnMax(double v1, double v2) {
145
        BigDecimal b1 = new BigDecimal(v1);
146
        BigDecimal b2 = new BigDecimal(v2);
147
        return b1.max(b2).doubleValue();
148
    }
149

150
    /**
151
     * 返回两个数中小的一个值
152
     *
153
     * @param v1 需要被对比的第一个数
154
     * @param v2 需要被对比的第二个数
155
     * @return 返回两个数中小的一个值
156
     */
157
    public static double returnMin(double v1, double v2) {
158
        BigDecimal b1 = new BigDecimal(v1);
159
        BigDecimal b2 = new BigDecimal(v2);
160
        return b1.min(b2).doubleValue();
161
    }
162

163
    /**
164
     * 精确对比两个数字
165
     *
166
     * @param v1 需要被对比的第一个数
167
     * @param v2 需要被对比的第二个数
168
     * @return 如果两个数一样则返回0，如果第一个数比第二个数大则返回1，反之返回-1
169
     */
170
    public static int compareTo(double v1, double v2) {
171
        BigDecimal b1 = BigDecimal.valueOf(v1);
172
        BigDecimal b2 = BigDecimal.valueOf(v2);
173
        return b1.compareTo(b2);
174
    }
175

176
}