Java中数值计算的精度问题

《Effective Java》这本书中提到，float和double只能用来做科学计算或者
是工程计算，在商业计算中我们要用 java.math.BigDecimal。BigDecimal，一共有4个够造
方法，如果需要精确计算，非要用String来够造BigDecimal不可！

给一个网上的流传的工具类Arith：
Java代码

import java.math.BigDecimal;   
  
/**  
 * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精  
 * 确的浮点数运算，包括加减乘除和四舍五入。  
 */  
public class Arith {   
    // 默认除法运算精度   
    private static final int DEF_DIV_SCALE = 10;   
  
    // 这个类不能实例化   
    private Arith() {   
    }   
  
    /**  
     * 提供精确的加法运算。  
     * @param v1    被加数  
     * @param v2    加数  
     * @return 两个参数的和  
     */  
    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 两个参数的差  
     */  
    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 两个参数的积  
     */  
    public static double mul(double v1, double v2) {   
        BigDecimal b1 = new BigDecimal(Double.toString(v1));   
        BigDecimal b2 = new BigDecimal(Double.toString(v2));   
           
        return b1.multiply(b2).doubleValue();   
    }   
  
    /**  
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到  
     * 小数点以后10位，以后的数字四舍五入。  
     * @param v1     被除数  
     * @param v2     除数  
     * @return 两个参数的商  
     */  
    public static double div(double v1, double v2) {   
        return div(v1, v2, DEF_DIV_SCALE);   
    }   
  
    /**  
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指  
     * 定精度，以后的数字四舍五入。  
     * @param v1            被除数  
     * @param v2             除数  
     *   
     * @param scale  表示表示需要精确到小数点以后几位。  
     *   
     * @return 两个参数的商  
     */  
    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();   
    }   
}  

记住，一定要用Double和double！
《Effective Java》这本书中提到，float和double只能用来做科学计算或者是工程计算，在商业计算中我们要用 java.math.BigDecimal。BigDecimal，一共有4个够造方法，如果需要精确计算，非要用String来够造BigDecimal不可！

Java中的基本类型float有着很严重的精度缺失问题，这个我主要是通过java.math.BigDecimal来弥补，但BigDecimal毕竟是一个类，有着对象的创建销毁等繁琐的事情，况且Java中类本身没有destroy（）方法，这就把一切对象的彻底销毁后内存的回收，变成了一个不可测的变数，纵使你调用了system.gc(),但此方法的执行时机却又是未知的；所以这就要求程序员要尽可能少的创建对象（当然这还与java本身的确非常消耗内存有关），当对象一旦不用，尽可能的置为null，否则当程序运行几次后就会发现内存占有率高居不下，甚至有导致死机可能。

 

BigDecimal还有一点要引起注意的是，两个对象即使值确实相等，但它们相比较时也可能会引起不等的结果，举个例子如：
BigDecimal testA = new BigDecimal(200);

BigDecimal testB = new BigDecimal(200.00);

 

也许你认为 testA.equals(testB)==true, 但结果是false。然而 testA.toString().equals(testB.toString())==true 却是正确的。这是因为testB.toString()的值为200，在进行类型转换时，它已把小数点后的两个零去掉了。

 

为了解决这个问题，我通常的做法是将它们的小数点位数补起后再进行比较，这样是肯定不会出错了。

testA = testA.setScale(2,5);

testB = testB.setScale(2,5);

 

此时testA.equals(testB)==true。

 

当然了你可以根据需要将小数点位数设多或设置少一点。

 

setScale（int,int）中

第一位数为设置的小数点位数，

第二位是四舍五入的界值，你可以随意修改，如6，就是大于等于6是就进位。

 

还有testA = testA.setScale(2,5)这种写法在用BigDecimal时将会一直出现，因为它必须要通过给自身返回值来替代已经存在的值，如果你这样写testA.add(new BigDecimal(0))，那你会发现你的结果并不是想象中的200，而是0。

 

当然加减乘除都是一样的。至于刚才的比较为何不用testA.floatValue(),当然还是因为会造成精度丢失的缘故了，当然如果你的小数位数不超过5位的话，也是可以的，如果是超过5位，那就和第五位的值有关了（因为它仅保留五位小数），显示如果第五位大于等于五，即使第六位为零，也会在第五位上加一，否则后面的只会被截掉！

说到这里，忽然想起javascript中的尾数和精度问题，javascript中有一个方法“toFixed()”,这个方法就是用来截取小数点后尾数的长度的。例：var a = 343.12345465;var b = b.toFixed(4);这样b小数点后的尾数就是4位了，注意，它是按照四舍五入进行截取的。