关于double,float的精度丢失(二)

为什么double转float不会出现数据误差，而float转double却误差如此之大？
class Text
{
        public static void main(String[] args)
        {
                float f = 0.15f;
                double d = f;
                        System.out.println("d="+d);//输出结果：0.15000000596046448        
                double d1 = 0.15;
                float  f1 = (float)d1;
                        System.out.println("f1="+f1);//输出结果：0.15
                double d2 = 0.15 + 0.15f;
                        System.out.println("d2="+d2);//输出结果：0.300000059604645
                 
                
                
        }
}

 

double转float,会丢失精度，这不难理解，因float 比double 精度低，详见“java float double精度为什么会丢失？”http://blog.csdn.net/abing37/article/details/5332798，但float、double类型计算出来的结果，为什么会不准确呢？这就有了LZ的三个问题：
1. 为什么结果会是这样呢？ 
2. 如何避免这样的问题发生？
3. 如何让float转double能得到实际的数据？

问题一：为什么结果会是这样呢？ 
　　关键一点是，  十进制的小数，二进制表示有时不够精确。浮点数值没办法用十进制来精确表示的原因要归咎于CPU表示浮点数的方法。整数可以用二进制精确表示 ，但小数就不一定了，原因在于浮点数由两部分组成：指数和尾数。 浮点数的值实际上是由一个特定的数学公式计算得到的。精度损失会在任何操作系统和编程环境中遇到，JAVA也难免。举个例子，0.9表示成二进制数：

                     0.9*2=1.8   取整数部分 1
                     0.8(1.8的小数部分)*2=1.6    取整数部分 1
                     0.6*2=1.2   取整数部分 1
                     0.2*2=0.4   取整数部分 0
                     0.4*2=0.8   取整数部分 0
                     0.8*2=1.6 取整数部分 1
                     0.6*2=1.2   取整数部分 0
                              .........      0.9二进制表示为(从上往下): 1100100100100......

           注意：上面的计算过程循环了，也就是说*2永远不可能消灭小数部分，这样算法将无限下去。很显然，小数的二进制表示有时是不可能精确的 。其实道理很简单，十进制系统中能不能准确表示出1/3呢？同样二进制系统也无法准确表示1/10。

如计算12.0f-11.9f，将一个float型转化为内存存储格式的步骤为：
      （1）先将这个实数的绝对值化为二进制格式。 
     （2）将这个二进制格式实数的小数点左移或右移n位，直到小数点移动到第一个有效数字的右边。 
     （3）从小数点右边第一位开始数出二十三位数字放入第22到第0位。 
     （4）如果实数是正的，则在第31位放入“0”，否则放入“1”。 
     （5）如果n 是左移得到的，说明指数是正的，第30位放入“1”。如果n是右移得到的或n=0，则第30位放入“0”。 
     （6）如果n是左移得到的，则将n减去1后化为二进制，并在左边加“0”补足七位，放入第29到第23位。如果n是右移得到的或n=0，则将n化为二进制后在左边加“0”补足七位，再各位求反，再放入第29到第23位。

11.9f 转为二进制：
       (1) 将11.9化为二进制后 大约是(主要是0.9无法准确表示)" 1011. 1110011001100110011001100..."。
       (2) 将小数点左移三位到第一个有效位右侧： "1. 011 11100110011001100110 "。 保证有效位数24位， 右侧多余的截取，误差就在这里产生了。
       步骤3~6，略。
     11.9f 为:   0 1 0000010 011 11100110011001100110

计算12.0f-11.9f：
12.0f 为： 0 1 0000010 10000000000000000000000
（两浮点数进行加减，首先要看两数的 指数位 是否相同，即小数点位置是否对齐。若相同，表示小数点是对齐的，就可以进行尾数的加减运算。若两数阶码不同，必须先对阶--使两数的阶码相同）12.0f 与 11.9f 指数位完全相同，只要对有效数位进行减法即可：
     12.0f-11.9f   结果：         0 1 0000010 00000011001100110011010
     将结果还原为十进制： 0.000 11001100110011010= 0.10000038 

问题二、三：如何避免这样的问题发生，如何能得到实际的数据？
　　float和double只适合做科学计算或者是工程计算，在商业计算中我们应用java.math.BigDecimal，注意一点，BigDecimal要用String来够造。我们可以下载工具类Arith，或自己调用BigDecimal，例如：

1. public static double add(double v1,double v2){
   
2. BigDecimal b1 = new BigDecimal(Double.toString(v1));
   
3. BigDecimal b2 = new BigDecimal(Double.toString(v2));
   
4. return b1.add(b2).doubleValue();
   
5. }