货币金额的计算 - Java中的BigDecimal


在《Effective Java》这本书中也提到这个原则,float和double只能用来做科学计算或者是工程计算,在商业计算中我们要用 java.math.BigDecimal。,而且使用BigDecimal类也可以进行大数的操作。

表11-15 BigDecimal类的常用方法,具体参考API 
http://download.java.net/jdk/jdk-api-localizations/jdk-api-zh-cn/builds/latest/html/zh_CN/api/

 

序号

    法

类型

    述

1

public BigDecimal(double val)

构造

将double表示形式转换

为BigDecimal

2

public BigDecimal(int val)

构造

将int表示形式转换为

BigDecimal

3

public BigDecimal(String val)

构造

将字符串表示

形式转换为BigDecimal

4

public BigDecimal add(BigDecimal augend)

普通

加法

5

public BigDecimal subtract(BigDecimal
subtrahend)

普通

减法

6

public BigDecimal multiply(BigDecimal
multiplicand)

普通

乘法

7

public BigDecimal divide(BigDecimal
divisor)

普通

除法

一、 BigDecimal的计算

复制代码
金额的计算BigDecimal类

double d = 9.84;
double d2 = 1.22;
//注意需要使用BigDecimal(String val)构造方法
BigDecimal bigDecimal = new BigDecimal(Double.toString(d));
BigDecimal bigDecimal2 = new BigDecimal(Double.toString(d2));

//加法
BigDecimal bigDecimalAdd = bigDecimal.add(bigDecimal2);
double add = bigDecimalAdd.doubleValue();

//减法
BigDecimal bigDecimalSubtract = bigDecimal.subtract(bigDecimal2);
double subtract = bigDecimalSubtract.doubleValue();

//乘法
BigDecimal bigDecimalMultiply = bigDecimal.multiply(bigDecimal2);
double multiply = bigDecimalMultiply.doubleValue();

//除法
int scale = 2;//保留2位小数
BigDecimal bigDecimalDivide = bigDecimal.divide(bigDecimal2, scale, BigDecimal.ROUND_HALF_UP);
double divide = bigDecimalDivide.doubleValue();

//格式化
double format = 12343171.6;

//获取常规数值格式
NumberFormat number = NumberFormat.getNumberInstance();
String str = number.format(format);//12,343,171.6

//获取整数数值格式
NumberFormat integer = NumberFormat.getIntegerInstance();
str = integer.format(format);//如果带小数会四舍五入到整数12,343,172

//获取货币数值格式
NumberFormat currency = NumberFormat.getCurrencyInstance();
currency.setMinimumFractionDigits(2);//设置数的小数部分所允许的最小位数(如果不足后面补0)
currency.setMaximumFractionDigits(4);//设置数的小数部分所允许的最大位数(如果超过会四舍五入)
str = currency.format(format);//¥12,343,171.60

//获取显示百分比的格式
NumberFormat percent = NumberFormat.getPercentInstance();
percent.setMinimumFractionDigits(2);//设置数的小数部分所允许的最小位数(如果不足后面补0)
percent.setMaximumFractionDigits(3);//设置数的小数部分所允许的最大位数(如果超过会四舍五入)
str = percent.format(format);//1,234,317,160.00% 
复制代码

 

二、典型的Double类型的数值运算

复制代码
 1 package com.wetalk.wbs.bas.util;
 2 
 3 import java.io.Serializable;
 4 import java.math.BigDecimal;
 5 import java.math.RoundingMode;
 6 
 7 /**
 8  * double的计算不精确,会有类似0.0000000000000002的误差,正确的方法是使用BigDecimal或者用整型
 9  * 整型地方法适合于货币精度已知的情况,比如12.11+1.10转成1211+110计算,最后再/100即可
10  * 以下是摘抄的BigDecimal方法:
11  */
12 public class DoubleUtil implements Serializable {
13     private static final long serialVersionUID = -3345205828566485102L;
14     // 默认除法运算精度
15     private static final Integer DEF_DIV_SCALE = 2;
16 
17     /**
18      * 提供精确的加法运算。
19      *
20      * @param value1 被加数
21      * @param value2 加数
22      * @return 两个参数的和
23      */
24     public static Double add(Double value1, Double value2) {
25         BigDecimal b1 = new BigDecimal(Double.toString(value1));
26         BigDecimal b2 = new BigDecimal(Double.toString(value2));
27         return b1.add(b2).doubleValue();
28     }
29 
30     /**
31      * 提供精确的减法运算。
32      *
33      * @param value1 被减数
34      * @param value2 减数
35      * @return 两个参数的差
36      */
37     public static double sub(Double value1, Double value2) {
38         BigDecimal b1 = new BigDecimal(Double.toString(value1));
39         BigDecimal b2 = new BigDecimal(Double.toString(value2));
40         return b1.subtract(b2).doubleValue();
41     }
42 
43     /**
44      * 提供精确的乘法运算。
45      *
46      * @param value1 被乘数
47      * @param value2 乘数
48      * @return 两个参数的积
49      */
50     public static Double mul(Double value1, Double value2) {
51         BigDecimal b1 = new BigDecimal(Double.toString(value1));
52         BigDecimal b2 = new BigDecimal(Double.toString(value2));
53         return b1.multiply(b2).doubleValue();
54     }
55 
56     /**
57      * 提供(相对)精确的除法运算,当发生除不尽的情况时, 精确到小数点以后10位,以后的数字四舍五入。
58      *
59      * @param dividend 被除数
60      * @param divisor  除数
61      * @return 两个参数的商
62      */
63     public static Double divide(Double dividend, Double divisor) {
64         return divide(dividend, divisor, DEF_DIV_SCALE);
65     }
66 
67     /**
68      * 提供(相对)精确的除法运算。 当发生除不尽的情况时,由scale参数指定精度,以后的数字四舍五入。
69      *
70      * @param dividend 被除数
71      * @param divisor  除数
72      * @param scale    表示表示需要精确到小数点以后几位。
73      * @return 两个参数的商
74      */
75     public static Double divide(Double dividend, Double divisor, Integer scale) {
76         if (scale < 0) {
77             throw new IllegalArgumentException("The scale must be a positive integer or zero");
78         }
79         BigDecimal b1 = new BigDecimal(Double.toString(dividend));
80         BigDecimal b2 = new BigDecimal(Double.toString(divisor));
81         return b1.divide(b2, scale,RoundingMode.HALF_UP).doubleValue();
82     }
83 
84     /**
85      * 提供指定数值的(精确)小数位四舍五入处理。
86      *
87      * @param value 需要四舍五入的数字
88      * @param scale 小数点后保留几位
89      * @return 四舍五入后的结果
90      */
91     public static double round(double value,int scale){
92         if(scale<0){
93             throw new IllegalArgumentException("The scale must be a positive integer or zero");
94         }
95         BigDecimal b = new BigDecimal(Double.toString(value));
96         BigDecimal one = new BigDecimal("1");
97         return b.divide(one,scale, RoundingMode.HALF_UP).doubleValue();
98     }
99 }
复制代码

三、下面提一下两个精度问题:

 
问题一:BigDecimal的精度问题(StackOverflow上有个家伙问了相关的问题)
System.out.println(new BigDecimal(0.1).toString()); // 0.1000000000000000055511151231257827021181583404541015625
System.out.println(new BigDecimal("0.1").toString()); // 0.1 System.out.println(new BigDecimal( Double.toString(0.1000000000000000055511151231257827021181583404541015625)).toString());// 0.1 System.out.println(new BigDecimal(Double.toString(0.1)).toString()); // 0.1

 

分析一下上面代码的问题(注释的内容表示此语句的输出)

第一行:事实上,由于二进制无法精确地表示十进制小数0.1,但是编译器读到字符串"0.1"之后,必须把它转成8个字节的double值,因 此,编译器只能用一个最接近的值来代替0.1了,即 0.1000000000000000055511151231257827021181583404541015625。因此,在运行时,传给 BigDecimal构造函数的真正的数值是 0.1000000000000000055511151231257827021181583404541015625。
第二行:BigDecimal能够正确地把字符串转化成真正精确的浮点数。
第三行:问题在于Double.toString会使用一定的精度来四舍五入double,然后再输出。会。 Double.toString(0.1000000000000000055511151231257827021181583404541015625) 输出的事实上是"0.1",因此生成的BigDecimal表示的数也是0.1。
第四行:基于前面的分析,事实上这一行代码等价于第三行
 
结论:
1.如果你希望BigDecimal能够精确地表示你希望的数值,那么一定要使用字符串来表示小数,并传递给BigDecimal的构造函数。
2.如果你使用Double.toString来把double转化字符串,然后调用BigDecimal(String),这个也是不靠谱的,它不一定按你的想法工作。
3.如果你不是很在乎是否完全精确地表示,并且使用了BigDecimal(double),那么要注意double本身的特例,double 的规范本身定义了几个特殊的double值(Infinite,-Infinite,NaN),不要把这些值传给BigDecimal,否则会抛出异常。
 
问题二:把double强制转化成int,难道不是扔掉小数部分吗?
int x=(int)1023.99999999999999; // x=1024为什么?

原因还是在于二进制无法精确地表示某些十进制小数,因此1023.99999999999999在编译之后的double值变成了1024。

所以, 把double强制转化成int确实是扔掉小数部分,但是你写在代码中的值,并不一定是编译器生成的真正的double值。
验证代码:
double d = 1023.99999999999999;
int x = (int) d;
System.out.println(new BigDecimal(d).toString()); // 1024 System.out.println(Long.toHexString(Double.doubleToRawLongBits(d))); // 4090000000000000 System.out.println(x); // 1024

前面提过BigDecimal可以精确地把double表示出来还记得吧。

我们也可以直接打印出d的二进制形式,根据IEEE 754的规定,我们可以算出0x4090000000000000=(1024)。

你可能感兴趣的:(Bigdecimal)