java基础数据类型、高精度数字对象的运算

一、java八大基础数据类型

Java八大基本数据类型

基本数据类型	大小（占内存空间）	取值范围	默认值(基础数据类型)	包装器类型
byte	8bit(1字节)	-128~+127	0	Byte
short	16bit(2字节)	-32768~32767	0	Short
int	32bit(4字节)	-(2^31)~+(2^31)-1	0	Integer
long	64bit(8字节)	-(2^63)~+(2^63)-1	0	Long
float	32bit(4字节)	-(3.402823447E+38F)~+(3.402823447E+38F)	0.0f	Float
double	64bit(8字节)	-(1.79769313486231570E+308) ~+(1.79769313486231570E+308)	0.0d	Double
char	16bit(2字节)	0~+(2^16)-1	"/u0000"	Char
boolean	1bit(1/8字节)	0、1	0	Boolean

注：Java中的基本数据类型全部直接全部实例化在栈(RAM区)内存中。

二、高精度数字对象

java提供了两个高精度数字对象：BigInteger(支持任意精度的整数)、BigDecimal(支持任意类型的浮点数)，这两个高精度数字对象以牺牲效率来提高运算的精度。具体运算方法如下所示：

1. import java.math.BigDecimal;  
2.   
3. public class ArithmeticUtil {   
4.   
5.     /*  
6.      * 小数精确的位数  
7.      */   
8.     private static final int DEF_DIV_SCALE = 10;   
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.     /**  
26.      * 提供精确的加法运算。  
27.      *  
28.      * @param v1  
29.      *            被加数  
30.      * @param v2  
31.      *            加数  
32.      * @return 两个参数的和  
33.      */   
34.     public static BigDecimal add(String v1, String v2) {   
35.         BigDecimal b1 = new BigDecimal(v1);   
36.         BigDecimal b2 = new BigDecimal(v2);   
37.         return b1.add(b2);   
38.     }   
39.      
40.     /**  
41.      * 提供精确的加法运算。 String  
42.      *  
43.      * @param v1  
44.      *            被加数  
45.      * @param v2  
46.      *            加数  
47.      * @return 两个参数的和  
48.      */   
49.     public static String strAdd(String v1, String v2,int scale) {   
50.         if (scale < 0) {   
51.             throw new IllegalArgumentException(   
52.                     "The scale must be a positive integer or zero");   
53.         }   
54.         BigDecimal b1 = new BigDecimal(v1);   
55.         BigDecimal b2 = new BigDecimal(v2);   
56.         return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();   
57.     }   
58.     /**  
59.      * 提供精确的减法运算。  
60.      *  
61.      * @param v1  
62.      *            被减数  
63.      * @param v2  
64.      *            减数  
65.      * @return 两个参数的差  
66.      */   
67.     public static double sub(double v1, double v2) {   
68.         BigDecimal b1 = new BigDecimal(Double.toString(v1));   
69.         BigDecimal b2 = new BigDecimal(Double.toString(v2));   
70.         return b1.subtract(b2).doubleValue();   
71.     }   
72.      
73.     /**  
74.      * 提供精确的减法运算。  
75.      *  
76.      * @param v1  
77.      *            被减数  
78.      * @param v2  
79.      *            减数  
80.      * @return 两个参数的差  
81.      */   
82.     public static BigDecimal sub(String v1, String v2) {   
83.         BigDecimal b1 = new BigDecimal(v1);   
84.         BigDecimal b2 = new BigDecimal(v2);   
85.         return b1.subtract(b2);   
86.     }   
87.      
88.     /**  
89.      * 对一个数字取精度  
90.      * @param v  
91.      * @param scale  
92.      * @return  
93.      */   
94.     public static BigDecimal round(String 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 = new BigDecimal(v);   
100.         BigDecimal one = new BigDecimal("1");   
101.         return b.divide(one, scale, BigDecimal.ROUND_HALF_UP);   
102.     }   
103.      
104.     /**  
105.      * 提供精确的减法运算。String  
106.      *  
107.      * @param v1  
108.      *            被减数  
109.      * @param v2  
110.      *            减数  
111.      * @return 两个参数的差  
112.      */   
113.     public static String strSub(String v1, String v2,int scale) {   
114.         if (scale < 0) {   
115.             throw new IllegalArgumentException(   
116.                     "The scale must be a positive integer or zero");   
117.         }   
118.         BigDecimal b1 = new BigDecimal(v1);   
119.         BigDecimal b2 = new BigDecimal(v2);   
120.         return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();   
121.     }   
122.     /**  
123.      * 提供精确的乘法运算。  
124.      *  
125.      * @param v1  
126.      *            被乘数  
127.      * @param v2  
128.      *            乘数  
129.      * @return 两个参数的积  
130.      */   
131.     public static double mul(double v1, double v2) {   
132.         BigDecimal b1 = new BigDecimal(Double.toString(v1));   
133.         BigDecimal b2 = new BigDecimal(Double.toString(v2));   
134.         return b1.multiply(b2).doubleValue();   
135.     }   
136.      
137.     /**  
138.      * 提供精确的乘法运算。  
139.      *  
140.      * @param v1  
141.      *            被乘数  
142.      * @param v2  
143.      *            乘数  
144.      * @return 两个参数的积  
145.      */   
146.     public static BigDecimal mul(String v1, String v2) {   
147.         BigDecimal b1 = new BigDecimal(v1);   
148.         BigDecimal b2 = new BigDecimal(v2);   
149.         return b1.multiply(b2);   
150.     }   
151.      
152.     /**  
153.      * 提供精确的乘法运算。 保留scale 位小数  
154.      *  
155.      * @param v1  
156.      *            被乘数  
157.      * @param v2  
158.      *            乘数  
159.      * @return 两个参数的积  
160.      */   
161.     public static double mul2(double v1, double v2,int scale) {   
162.         BigDecimal b1 = new BigDecimal(Double.toString(v1));   
163.         BigDecimal b2 = new BigDecimal(Double.toString(v2));   
164.         return  round(b1.multiply(b2).doubleValue(),scale);   
165.     }   
166.      
167.     /**  
168.      * 提供精确的乘法运算。 保留scale 位小数 String  
169.      *  
170.      * @param v1  
171.      *            被乘数  
172.      * @param v2  
173.      *            乘数  
174.      * @return 两个参数的积  
175.      */   
176.     public static String strMul2(String v1, String v2,int scale) {   
177.         if (scale < 0) {   
178.             throw new IllegalArgumentException(   
179.                     "The scale must be a positive integer or zero");   
180.         }   
181.         BigDecimal b1 = new BigDecimal(v1);   
182.         BigDecimal b2 = new BigDecimal(v2);   
183.         return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();   
184.     }   
185.     /**  
186.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。  
187.      *  
188.      * @param v1  
189.      *            被除数  
190.      * @param v2  
191.      *            除数  
192.      * @return 两个参数的商  
193.      */   
194.     public static BigDecimal div(String v1, String v2) {   
195.         return div(v1, v2, DEF_DIV_SCALE);   
196.     }   
197.      
198.     /**  
199.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。  
200.      *  
201.      * @param v1  
202.      *            被除数  
203.      * @param v2  
204.      *            除数  
205.      * @return 两个参数的商  
206.      */   
207.     public static double div(double v1, double v2) {   
208.         return div(v1, v2, DEF_DIV_SCALE);   
209.     }   
210.   
211.     /**  
212.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。  
213.      *  
214.      * @param v1  
215.      *            被除数  
216.      * @param v2  
217.      *            除数  
218.      * @param scale  
219.      *            表示需要精确到小数点以后几位。  
220.      * @return 两个参数的商  
221.      */   
222.     public static double div(double v1, double v2, int scale) {   
223.         if (scale < 0) {   
224.             throw new IllegalArgumentException(   
225.                     "The scale must be a positive integer or zero");   
226.         }   
227.         BigDecimal b1 = new BigDecimal(Double.toString(v1));   
228.         BigDecimal b2 = new BigDecimal(Double.toString(v2));   
229.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();   
230.     }   
231.      
232.     /**  
233.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。  
234.      *  
235.      * @param v1  
236.      *            被除数  
237.      * @param v2  
238.      *            除数  
239.      * @param scale  
240.      *            表示需要精确到小数点以后几位。  
241.      * @return 两个参数的商  
242.      */   
243.     public static BigDecimal div(String v1, String v2, int scale) {   
244.         if (scale < 0) {   
245.             throw new IllegalArgumentException(   
246.                     "The scale must be a positive integer or zero");   
247.         }   
248.         BigDecimal b1 = new BigDecimal(v1);   
249.         BigDecimal b2 = new BigDecimal(v2);   
250.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP);   
251.     }   
252.   
253.     /**  
254.      * 精确的除法运算。除不尽时，由scale参数指 定精度 四舍五入。string  
255.      *  
256.      * @param v1  
257.      *            被除数  
258.      * @param v2  
259.      *            除数  
260.      * @param scale  
261.      *            表示需要精确到小数点以后几位。  
262.      * @return 两个参数的商  
263.      */   
264.     public static String strDiv(String v1, String v2, int scale) {   
265.         if (scale < 0) {   
266.             throw new IllegalArgumentException(   
267.                     "The scale must be a positive integer or zero");   
268.         }   
269.         BigDecimal b1 = new BigDecimal(v1);   
270.         BigDecimal b2 = new BigDecimal(v2);   
271.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();   
272.     }   
273.      
274.     /**  
275.      * 精确的除法运算。除不尽时，由scale参数指 定精度 四舍五入。string  
276.      *  
277.      * @param v1  
278.      *            被除数  
279.      * @param v2  
280.      *            除数  
281.      * @param scale  
282.      *            表示需要精确到小数点以后几位。  
283.      * @return 两个参数的商  
284.      */   
285.     public static BigDecimal bigDiv(String v1, String v2, int scale) {   
286.         if (scale < 0) {   
287.             throw new IllegalArgumentException(   
288.                     "The scale must be a positive integer or zero");   
289.         }   
290.         BigDecimal b1 = new BigDecimal(v1);   
291.         BigDecimal b2 = new BigDecimal(v2);   
292.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP);   
293.     }   
294.     /**  
295.      * 取余数  string  
296.      * @param v1  
297.      * @param v2  
298.      * @param scale  
299.      * @return  
300.      */   
301.     public static BigDecimal strRemainder(String v1,String v2, int scale){   
302.         if (scale < 0) {   
303.             throw new IllegalArgumentException(   
304.                     "The scale must be a positive integer or zero");   
305.         }   
306.         BigDecimal b1 = new BigDecimal(v1);   
307.         BigDecimal b2 = new BigDecimal(v2);   
308.         return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP);   
309.     }   
310.     /**  
311.      * 取余数  string  
312.      * @param v1  
313.      * @param v2  
314.      * @param scale  
315.      * @return  string  
316.      */   
317.     public static String strRemainder2Str(String v1,String v2, int scale){   
318.         if (scale < 0) {   
319.             throw new IllegalArgumentException(   
320.                     "The scale must be a positive integer or zero");   
321.         }   
322.         BigDecimal b1 = new BigDecimal(v1);   
323.         BigDecimal b2 = new BigDecimal(v2);   
324.         return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();   
325.     }   
326.      
327.     /**  
328.      * 比较大小 如果v1 大于v2 则 返回true 否则false  
329.      * @param v1  
330.      * @param v2  
331.      * @return  
332.      */   
333.     public static boolean strcompareTo(String v1,String v2){   
334.         BigDecimal b1 = new BigDecimal(v1);   
335.         BigDecimal b2 = new BigDecimal(v2);   
336.         int bj = b1.compareTo(b2);   
337.         boolean res ;   
338.         if(bj>0)   
339.             res = true;   
340.         else   
341.             res = false;   
342.         return res;   
343.     }   
344.      
345.     /**  
346.      * 比较大小 如果v1 大于等于v2 则 返回true 否则false  
347.      * @param v1  
348.      * @param v2  
349.      * @return  
350.      */   
351.     public static boolean strcompareTo2(String v1,String v2){   
352.         BigDecimal b1 = new BigDecimal(v1);   
353.         BigDecimal b2 = new BigDecimal(v2);   
354.         int bj = b1.compareTo(b2);   
355.         boolean res ;   
356.         if(bj>=0)   
357.             res = true;   
358.         else   
359.             res = false;   
360.         return res;   
361.     }   
362.      
363.     /**  
364.      * 比较大小 如果v1 等于v2 则 返回true 否则false  
365.      * @param v1  
366.      * @param v2  
367.      * @return  
368.      */   
369.     public static boolean strcompareTo3(String v1,String v2){   
370.         BigDecimal b1 = new BigDecimal(v1);   
371.         BigDecimal b2 = new BigDecimal(v2);   
372.         int bj = b1.compareTo(b2);   
373.         boolean res ;   
374.         if(bj==0)   
375.             res = true;   
376.         else   
377.             res = false;   
378.         return res;   
379.     }   
380.       
381.     /**  
382.      * 取余数  BigDecimal  
383.      * @param v1  
384.      * @param v2  
385.      * @param scale  
386.      * @return  
387.      */   
388.     public static BigDecimal bigRemainder(BigDecimal v1,BigDecimal v2, int scale){   
389.         if (scale < 0) {   
390.             throw new IllegalArgumentException(   
391.                     "The scale must be a positive integer or zero");   
392.         }   
393.         return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);   
394.     }   
395.       
396.     /**  
397.      * 提供精确的小数位四舍五入处理。  
398.      *  
399.      * @param v  
400.      *            需要四舍五入的数字  
401.      * @param scale  
402.      *            小数点后保留几位  
403.      * @return 四舍五入后的结果  
404.      */   
405.     public static double round(double v, int scale) {   
406.         if (scale < 0) {   
407.             throw new IllegalArgumentException(   
408.                     "The scale must be a positive integer or zero");   
409.         }   
410.         BigDecimal b = new BigDecimal(Double.toString(v));   
411.         BigDecimal one = new BigDecimal("1");   
412.         return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();   
413.     }   
414.      
415.     /**  
416.      * 提供精确的小数位四舍五入处理。string  
417.      *  
418.      * @param v  
419.      *            需要四舍五入的数字  
420.      * @param scale  
421.      *            小数点后保留几位  
422.      * @return 四舍五入后的结果  
423.      */   
424.     public static String strRound(String v, int scale) {   
425.         if (scale < 0) {   
426.             throw new IllegalArgumentException(   
427.                     "The scale must be a positive integer or zero");   
428.         }   
429.         BigDecimal b = new BigDecimal(v);   
430.         return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();   
431.     }   
432.      
433.      
434. }  
     

高精度数字对象的运算参考：http://zhenchengchagangzi.iteye.com/blog/1258453