数学运算工具类

Java代码 

1. import java.math.BigDecimal;  
2.   
3. public class NumberUtil {  
4.   
5.     private static final int DEFAULT_DIV_SCALE = 10;  
6.   
7.     /** 
8.      * 相加 
9.      * @param v1 
10.      * @param v2 
11.      * @return double 
12.      */  
13.     public static double add(double v1, double v2)  
14.   
15.     {  
16.   
17.         BigDecimal b1 = new BigDecimal(Double.toString(v1));  
18.   
19.         BigDecimal b2 = new BigDecimal(Double.toString(v2));  
20.   
21.         return b1.add(b2).doubleValue();  
22.   
23.     }  
24.   
25.       
26.     public static String add(String v1, String v2)  
27.   
28.     {  
29.   
30.         BigDecimal b1 = new BigDecimal(v1);  
31.   
32.         BigDecimal b2 = new BigDecimal(v2);  
33.   
34.         return b1.add(b2).toString();  
35.   
36.     }  
37.   
38.     /** 
39.      * 相减 
40.      * @param v1 
41.      * @param v2 
42.      * @return  
43.      */  
44.     public static double subtract(double v1, double v2)  
45.   
46.     {  
47.   
48.         BigDecimal b1 = new BigDecimal(Double.toString(v1));  
49.   
50.         BigDecimal b2 = new BigDecimal(Double.toString(v2));  
51.   
52.         return b1.subtract(b2).doubleValue();  
53.   
54.     }  
55.   
56.     public static String subtract(String v1, String v2)  
57.   
58.     {  
59.   
60.         BigDecimal b1 = new BigDecimal(v1);  
61.   
62.         BigDecimal b2 = new BigDecimal(v2);  
63.   
64.         return b1.subtract(b2).toString();  
65.   
66.     }  
67.   
68.     /** 
69.      * 相乘 
70.      * @param v1 
71.      * @param v2 
72.      * @return  
73.      */  
74.     public static double multiply(double v1, double v2)  
75.   
76.     {  
77.   
78.         BigDecimal b1 = new BigDecimal(Double.toString(v1));  
79.   
80.         BigDecimal b2 = new BigDecimal(Double.toString(v2));  
81.   
82.         return b1.multiply(b2).doubleValue();  
83.   
84.     }  
85.   
86.     public static String multiply(String v1, String v2)  
87.   
88.     {  
89.   
90.         BigDecimal b1 = new BigDecimal(v1);  
91.   
92.         BigDecimal b2 = new BigDecimal(v2);  
93.   
94.         return b1.multiply(b2).toString();  
95.   
96.     }  
97.   
98.     /** 
99.      * 相除 
100.      * @param v1 
101.      * @param v2 
102.      * @return double 
103.      */  
104.     public static double divide(double v1, double v2)  
105.   
106.     {  
107.   
108.         return divide(v1, v2, DEFAULT_DIV_SCALE);  
109.   
110.     }  
111.   
112.     public static double divide(double v1, double v2, int scale)  
113.   
114.     {  
115.   
116.         return divide(v1, v2, scale, BigDecimal.ROUND_HALF_EVEN);  
117.   
118.     }  
119.   
120.     public static double divide(double v1, double v2, int scale, int round_mode) {  
121.   
122.         if (scale < 0)  
123.   
124.         {  
125.   
126.             throw new IllegalArgumentException(  
127.                     "The scale must be a positive integer or zero");  
128.   
129.         }  
130.   
131.         BigDecimal b1 = new BigDecimal(Double.toString(v1));  
132.   
133.         BigDecimal b2 = new BigDecimal(Double.toString(v2));  
134.   
135.         return b1.divide(b2, scale, round_mode).doubleValue();  
136.   
137.     }  
138.   
139.     public static String divide(String v1, String v2)  
140.   
141.     {  
142.   
143.         return divide(v1, v2, DEFAULT_DIV_SCALE);  
144.   
145.     }  
146.   
147.     public static String divide(String v1, String v2, int scale)  
148.   
149.     {  
150.   
151.         return divide(v1, v2, DEFAULT_DIV_SCALE, BigDecimal.ROUND_HALF_EVEN);  
152.   
153.     }  
154.   
155.     public static String divide(String v1, String v2, int scale, int round_mode)  
156.   
157.     {  
158.   
159.         if (scale < 0)  
160.   
161.         {  
162.   
163.             throw new IllegalArgumentException(  
164.                     "The scale must be a positive integer or zero");  
165.   
166.         }  
167.   
168.         BigDecimal b1 = new BigDecimal(v1);  
169.   
170.         BigDecimal b2 = new BigDecimal(v2);  
171.   
172.         return b1.divide(b2, scale, round_mode).toString();  
173.   
174.     }  
175.   
176.     public static double round(double v, int scale)  
177.   
178.     {  
179.   
180.         return round(v, scale, BigDecimal.ROUND_HALF_EVEN);  
181.   
182.     }  
183.   
184.     public static double round(double v, int scale, int round_mode)  
185.   
186.     {  
187.   
188.         if (scale < 0)  
189.   
190.         {  
191.   
192.             throw new IllegalArgumentException(  
193.                     "The scale must be a positive integer or zero");  
194.   
195.         }  
196.   
197.         BigDecimal b = new BigDecimal(Double.toString(v));  
198.   
199.         return b.setScale(scale, round_mode).doubleValue();  
200.   
201.     }  
202.   
203.     public static String round(String v, int scale)  
204.   
205.     {  
206.   
207.         return round(v, scale, BigDecimal.ROUND_HALF_EVEN);  
208.   
209.     }  
210.   
211.     public static String round(String v, int scale, int round_mode)  
212.   
213.     {  
214.   
215.         if (scale < 0)  
216.   
217.         {  
218.   
219.             throw new IllegalArgumentException(  
220.                     "The scale must be a positive integer or zero");  
221.   
222.         }  
223.   
224.         BigDecimal b = new BigDecimal(v);  
225.   
226.         return b.setScale(scale, round_mode).toString();  
227.     }  
228.   
229.     public static void main(String[] args) {  
230.         System.out.println(2.21 - 2);  
231.         System.out.println(7 * 0.8);  
232.   
233.         System.out.println(subtract(312.21, 312));  
234.         System.out.println(multiply(7, 0.8));  
235.     }  
236.   
237. }