java中金融货币运算处理方法

总结：精确运算要用String构造的BigDecimal，不要用float和double！

BigDecimal

在金额运算处理方法中，我们一般禁止使用double和float进行运算，否则会造成精度的丢失，导致最终计算记过不够精确。

在《你可能不知道的Java基础知识（一）》中，我提到使用浮点运算要慎重，感觉说的不够透彻，其实float和double类型主要是为科学和工程计算而设计的。他们执行的是二进制浮点运算，由于二进制的局限性，有时候无法得到准确的结果。

例如：System.out.println(2.0-1.1)将输出0.8999999999999999，而不是0.9，当然这在科学计算中无关紧要，通过四舍五入就可以轻松解决问题，但是在禁止出现舍入误差的运算中（比如金融计算）就不适用了。

在二进制中无法精确地表示10的任何负数次方值，比如0.1，这和十进制中无法精确表示1/3一个道理，所以越到像金融货币计算的问题，我们不得不舍弃float和double，而改BigDecimal类。

用BigDecimal解决上述2.0-1.1问题的代码为：

import java.math.*;  
class BigDecimalTest   
{  
    public static void main(String[] args)   
    {  
        //使用字符串构造BigDecimal对象  
        BigDecimal a =new BigDecimal("2.0");  
        BigDecimal b = new BigDecimal("1.1");  
        System.out.println(a.subtract(b));  
    }  
}  
  
输出：0.9  

假如不用String来构造BigDecimal问题将依旧：

import java.math.*;  
class TestB   
{  
    public static void main(String[] args)   
    {  
        //使用double来构造BigDecimal，问题依旧  
        BigDecimal a = new BigDecimal(2.0);  
        BigDecimal b = new BigDecimal(1.1);  
        System.out.println(a.subtract(b));  
    }  
}  
输出 0.899999999999999911182158029987476766109466552734375  

在实际运算中我们要使用BigDecimal进行加减乘除运算。但是，尤其是在进行除法运算时，一点要进行小数点处理，否则会引起代码运行报错。

package com.morningstar.bigdecimal;  
  
import java.math.BigDecimal;  
  
public class Arithmetic4Double {  
    //默认除法运算精度  
    private static final int DEF_DIV_SCALE = 10;  
     
    //所有方法均用静态方法实现，不允许实例化  
    private Arithmetic4Double() {}  
  
    /** 
     * 实现浮点数的加法运算功能 
     * @param v1 加数1 
     * @param v2 加数2 
     * @return v1+v2的和 
     */  
    public static double add(double v1,double v2) {  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.add(b2).doubleValue();  
    }  
    /** 
     * 实现浮点数的减法运算功能 
     * @param v1 被减数 
     * @param v2 减数 
     * @return v1-v2的差 
     */  
    public static double sub(double v1,double v2) {  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.subtract(b2).doubleValue();  
    }  
    /** 
     * 实现浮点数的乘法运算功能 
     * @param v1 被乘数 
     * @param v2 乘数 
     * @return v1×v2的积 
     */  
    public static double multi(double v1,double v2) {  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.multiply(b2).doubleValue();  
    }  
  
    /** 
     * 实现浮点数的除法运算功能 
     * 当发生除不尽的情况时，精确到小数点以后DEF_DIV_SCALE位(默认为10位)，后面的位数进行四舍五入。 
     * @param v1 被除数 
     * @param v2 除数 
     * @return v1/v2的商 
     */  
    public static double div(double v1,double v2) {  
     BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.divide(b2,DEF_DIV_SCALE,BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
  
    /** 
     * 实现浮点数的除法运算功能 
     * 当发生除不尽的情况时，精确到小数点以后scale位，后面的位数进行四舍五入。 
     * @param v1 被除数 
     * @param v2 除数 
     * @param scale 表示需要精确到小数点以后几位 
     * @return v1/v2的商 
     */  
    public static double div(double v1,double v2,int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException(  
                "The scale must be a positive integer or zero");  
        }  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
  
    /** 
     * 提供精确的小数位四舍五入功能 
     * @param v 需要四舍五入的数字 
     * @param scale 小数点后保留几位 
     * @return 四舍五入后的结果 
     */  
    public static double round(double v,int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException(  
                "The scale must be a positive integer or zero");  
        }  
        BigDecimal b = new BigDecimal(Double.toString(v));  
        BigDecimal one = new BigDecimal("1");  
        return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
}  

**

BigDecimal.ROUND_HALF_XXX的各种用法

**
在银行、帐户、计费等领域，BigDecimal提供了精确的数值计算。其中8种舍入方式值得掌握。

1、ROUND_UP

舍入远离零的舍入模式。

在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1)。

注意，此舍入模式始终不会减少计算值的大小。

2、ROUND_DOWN

接近零的舍入模式。

在丢弃某部分之前始终不增加数字(从不对舍弃部分前面的数字加1，即截短)。

注意，此舍入模式始终不会增加计算值的大小。

3、ROUND_CEILING

接近正无穷大的舍入模式。

如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同;

如果为负，则舍入行为与 ROUND_DOWN 相同。

注意，此舍入模式始终不会减少计算值。

4、ROUND_FLOOR

接近负无穷大的舍入模式。

如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同;

如果为负，则舍入行为与 ROUND_UP 相同。

注意，此舍入模式始终不会增加计算值。

5、ROUND_HALF_UP

向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。

如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同。

注意，这是我们大多数人在小学时就学过的舍入模式(四舍五入)。

6、ROUND_HALF_DOWN

向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。

如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同(五舍六入)。

7、ROUND_HALF_EVEN 银行家舍入法

向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。

如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同;

如果为偶数，则舍入行为与 ROUND_HALF_DOWN 相同。

注意，在重复进行一系列计算时，此舍入模式可以将累加错误减到最小。

此舍入模式也称为“银行家舍入法”，主要在美国使用。四舍六入，五分两种情况。

如果前一位为奇数，则入位，否则舍去。

以下例子为保留小数点1位，那么这种舍入方式下的结果。

1.15>1.2 1.25>1.2

8、ROUND_UNNECESSARY

断言请求的操作具有精确的结果，因此不需要舍入。

如果对获得精确结果的操作指定此舍入模式，则抛出ArithmeticException。

因为我们是属于互联网金融行业，所有在进行计算的时候尽量使用ROUND_HALF_EVEN 银行家舍入法