java BigDecimal 高精度运算小数点处理详解

以你之姓@ 2022-07-31 01:52 354阅读 0赞

保留两位小数\{

方法一：\{

double   c=3.154215;

java.text.DecimalFormat myformat=new java.text.DecimalFormat("0.00");

String str = myformat.format(c);      
\}

方式二：\{

java.text.DecimalFormat   df   =new   java.text.DecimalFormat("\#.00");   
   df.format(你要格式化的数字);

例：new java.text.DecimalFormat("\#.00").format(3.1415926)

\#.00 表示两位小数 \#.0000四位小数 以此类推...  
\}

方式三：\{

double d = 3.1415926;

String result = String .format("%.2f");

%.2f %. 表示 小数点前任意位数   2 表示两位小数 格式后的结果为f 表示浮点型  
\}

四舍五入 \{

double   f   =   111231.5585;   
BigDecimal   b   =   new   BigDecimal(f);   
//保留2位小数  
double   f1   =   b.setScale(2,   BigDecimal.ROUND\_HALF\_UP).doubleValue();   
\}

**\[java\]**  [view plain][]  [copy][view plain]

1.  **public** **class** PreciseCompute \{  
2.  //默认除法运算精度  
3.  **private** **static** **final** **int** DEF\_DIV\_SCALE = 10;  
4.    
5.  /\*\* 
6.  \* 提供精确的加法运算。 
7.  \* @param v1 被加数 
8.  \* @param v2 加数 
9.  \* @return 两个参数的和 
10. \*/  
11.   
12. **public** **static** **double** add(**double** v1, **double** v2) \{  
13.    BigDecimal b1 = **new** BigDecimal(Double.toString(v1));  
14.    BigDecimal b2 = **new** BigDecimal(Double.toString(v2));  
15.    **return** b1.add(b2).doubleValue();  
16. \}  
17.   
18. /\*\* 
19. \* 提供精确的减法运算。 
20. \* @param v1 被减数 
21. \* @param v2 减数 
22. \* @return 两个参数的差 
23. \*/  
24.   
25. **public** **static** **double** sub(**double** v1, **double** v2) \{  
26.    BigDecimal b1 = **new** BigDecimal(Double.toString(v1));  
27.    BigDecimal b2 = **new** BigDecimal(Double.toString(v2));  
28.    **return** b1.subtract(b2).doubleValue();  
29. \}  
30.   
31. /\*\* 
32. \* 提供精确的乘法运算。 
33. \* @param v1 被乘数 
34. \* @param v2 乘数 
35. \* @return 两个参数的积 
36. \*/  
37. **public** **static** **double** mul(**double** v1, **double** v2) \{  
38.    BigDecimal b1 = **new** BigDecimal(Double.toString(v1));  
39.    BigDecimal b2 = **new** BigDecimal(Double.toString(v2));  
40.    **return** b1.multiply(b2).doubleValue();  
41. \}  
42.   
43. /\*\* 
44. \* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 
45. \* 小数点以后10位，以后的数字四舍五入。 
46. \* @param v1 被除数 
47. \* @param v2 除数 
48. \* @return 两个参数的商 
49. \*/  
50.   
51. **public** **static** **double** div(**double** v1, **double** v2) \{  
52.    **return** div(v1, v2, DEF\_DIV\_SCALE);  
53. \}  
54.   
55. /\*\* 
56. \* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 
57. \* 定精度，以后的数字四舍五入。 
58. \* @param v1 被除数 
59. \* @param v2 除数 
60. \* @param scale 表示表示需要精确到小数点以后几位。 
61. \* @return 两个参数的商 
62. \*/  
63. **public** **static** **double** div(**double** v1, **double** v2, **int** scale) \{  
64.    **if** (scale < 0) \{  
65.     **throw** **new** IllegalArgumentException(  
66.       "The scale must be a positive integer or zero");  
67.    \}  
68.    BigDecimal b1 = **new** BigDecimal(Double.toString(v1));  
69.    BigDecimal b2 = **new** BigDecimal(Double.toString(v2));  
70.    **return** b1.divide(b2, scale, BigDecimal.ROUND\_HALF\_UP).doubleValue();  
71. \}  
72.   
73. /\*\* 
74. \* 提供精确的小数位四舍五入处理。 
75. \* @param v 需要四舍五入的数字 
76. \* @param scale 小数点后保留几位 
77. \* @return 四舍五入后的结果 
78. \*/  
79. **public** **static** **double** round(**double** v, **int** scale) \{  
80.    **if** (scale < 0) \{  
81.     **throw** **new** IllegalArgumentException(  
82.       "The scale must be a positive integer or zero");  
83.    \}  
84.    BigDecimal b = **new** BigDecimal(Double.toString(v));  
85.    BigDecimal ne = **new** BigDecimal("1");  
86.    **return** b.divide(one, scale, BigDecimal.ROUND\_HALF\_UP).doubleValue();  
87. \}  
88. \}

my code:

**\[java\]**  [view plain][]  [copy][view plain]

1.  **private** BigDecimal formatComma2BigDecimal(Object obj) \{  
2.          String val = String.valueOf(obj);  
3.          **if** (val == **null**)  
4.              **return** **new** BigDecimal("0.00");  
5.    
6.          val = val.replaceAll(",", "");  
7.          **if** (!isNumber(val))  
8.              **return** **new** BigDecimal("0.00");  
9.    
10.         BigDecimal decimal = **new** BigDecimal(val);  
11.         decimal = decimal.setScale(2, RoundingMode.HALF\_UP);  
12.   
13.         **return** decimal;  
14.   
15.     \}  
16.     **private** String formatCommaAnd2Point(Object obj) \{  
17.         BigDecimal decimal = formatComma2BigDecimal(obj);  
18.   
19.         DecimalFormat df = **new** DecimalFormat("\#,\#\#\#.00");  
20.         String decimalStr = df.format(decimal).equals(".00")?"0.00":df.format(decimal);  
21.         **if**(decimalStr.startsWith("."))\{  
22.             decimalStr = "0"\+decimalStr;  
23.         \}  
24.         **return** decimalStr;  
25.     \}  
26.     **private** **boolean** isDouble(String value) \{  
27.         **try** \{  
28.             Double.parseDouble(value);  
29.             **if** (value.contains("."))  
30.                 **return** **true**;  
31.             **return** **false**;  
32.         \} **catch** (NumberFormatException e) \{  
33.             **return** **false**;  
34.         \}  
35.     \}  
36.     **private** **boolean** isInteger(String value) \{  
37.         **try** \{  
38.             Integer.parseInt(value);  
39.             **return** **true**;  
40.         \} **catch** (NumberFormatException e) \{  
41.             **return** **false**;  
42.         \}  
43.     \}  
44.     **private** **boolean** isNumber(String value) \{  
45.         **return** isInteger(value) || isDouble(value);  
46.     \}

[view plain]: http://blog.csdn.net/lhooouuu/article/details/7086880#