Java精确计算浮点型数据--金融商业计算

注：本文转自http://www.51testing.com/?uid-141188-action-viewspace-itemid-72575

在《Effective Java》这本书中也提到这个原则，float和double只能用来做科学计算或是工程计算，在商业计算中我们要用 java.math.BigDecimal。BigDecimal一共有4个够造方法，我们不关心用BigInteger来够造的那两个，那么更有两个， 他们是：

BigDecimal(double val)

Translates a double into a BigDecimal.

BigDecimal(String val)

Translates the String repre sentation of a BigDecimal into a BigDecimal.

上面的API简要描述相当的明确，而且通常情况下，上面的那一个使用起来要方便一些。我们可能想都不想就用上了，会有什么问题呢？等到出了问题的时候，才发现上面哪个够造方法的周详说明中有这么一段：

Note: the results of this constructor can be somewhat unpredictable. One might assume that new BigDecimal(.1) is exactly equal to .1, but it is actually equal to .1000000000000000055511151231257827021181583404541015625. This is so because .1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length). Thus, the long value that is being passed in to the constructor is not exactly equal to .1, appearances nonwithstanding.

The (String) constructor, on the other hand, is perfectly predictable: new BigDecimal(".1") is exactly equal to .1, as one would expect. Therefore, it is generally recommended that the (String) constructor be used in preference to this one.

原来我们如果需要精确计算，非要用String来够造BigDecimal不可！在《Effective Java》一书中的例子是用String来够造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();
    }
}