Java中float和double转换的问题？

Question

为什么double转float不会出现数据误差，而float转double却误差如此之大？double d = 3.14;float f = (float)d;System.out.println(f);输出结果是:3.14;  float f = 127.1f;double d = f;System.out.println(d);输出结果是：127.0999984741211 为什么结果会是这样呢？如何避免这样的问题发生，让float转double能得到实际的数据？

Answer 1

JAVA中float为四个字节，double为八个字节，float--->double时候会补位，如果这里补位不出现误差的话应该可以实现。你先将float类型数据包装成BigDecimal数据，然后调用其floatValue()方法可以实现。
具体代码没有去实现了，这样应该可以。

Answer 2

1楼BigDecimal的方法不可行好像

Answer 3

float--->double
是属于强制转换，会丢失精度的

Answer 4

float f = 127.1f;
BigDecimal b = new BigDecimal(String.valueOf(f));
double d = b.doubleValue();
System.out.println(d);
你可以试下这段代码本来都不精确+1

Answer 5

 /**   
            *   提供精確的加法運算   
            *   @param   args   
            */   
          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   args   
            */   
          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   args   
            */   
          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   args   
            */   
          public   static   double   div(double   v1,   double   v2)   {   
                  return   div(v1,   v2,   DEF_DIV_SCALE);   
          }   
            
          /**   
            *   提供了(相對)精確的除法運算，當發生除不儘的情況時，由scale參數指定   
            *   精度，以後的數字四捨五入   
            *   @param   args   
            */   
          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   args   
            */   
            
          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_DOWN).doubleValue();   
          }   
    
          public   static   void   main(String[]   args)   {   
                  System.out.println(add(1.2321231,   3.7865765));   
                  System.out.println(sub(6.4523423,   1.2321231));   
                  System.out.println(mul(6.4523423,   3.7865765));   
                  System.out.println(div(6.4523423,   3.7865765,   5));   
                  System.out.println(round(3.7865765,   5));   
          }   
  } 
JAVA中float为四个字节，double为八个字节，float--->double时候会补位，如果这里补位不出现误差的话应该可以实现。你先将float类型数据包装成BigDecimal数据，然后调用其floatValue()方法可以实现。

Answer 6

我也没有测试过，晚上因为太晚了，float-->double要补位，还真不知道精确不，如果是要得到精确double进行计算，BigDecimal包装double数据，然后计算，最后调用其doubleValue()就容易实现。。
坐等达人出现了~~我觉得BigDecimal类应该可以实现的，你可以去查一下api

Answer 7

弄反了吧，double to float才是强制转换，float--->double转换会扩充精度的，float的精度可能为0.0000001，而double的精度可能为0.0000000000001这样转换后可能会有0.0000001 - 0.0000000000001(~=0.0000001)的误差

Answer 8

float f = 127.1f;
BigDecimal b = new BigDecimal(Float.toString(f));
double d = b.doubleValue();
System.out.println(d);---------这样可以不丢失精度--------

Answer 9

是因为doble比float更精确的缘故··

Answer 10

double转float肯定会丢失精度，只不过你现在转换的值的位数满足float的位数要求而已这些基础问题自己google解决问题啊

Answer 11

先把float型的变成String类型的，然后再装换成Double的

Answer 12

不是误差 float转double是合法转换
之所以那样是因为float为四个字节，double为八个字节
转化为double时 被扩展了 
你想想 原来小数点后只有7位精度 现在要变成16位 是被扩展了 而不是误差

Answer 13

JAVA中double类型float类型计算都会有精度差，所以推荐使用BigDecimal

Answer 14

我试验发现其实这就是个简单的类型转换问题同一个数~float可以向double自动提升，由原来的4个字节变8个字节产生类位数扩展，所以出现精度问题，其实是自动补位造成的~~float f = 127.1f;
double d = f;
ystem.out.println(d);
输出结果是：127.0999984741211
 double向float转换时，是强制类型转换~有8个字节强制变4个字节~那它就强制丢弃后4个字节，你就是强制丢失精度，所以不会出现小数点很多的情况 double d = 3.14; float f = (float)d; System.out.println(f); 输出结果是:3.14;
由此看来基础真的是太重要啦 
不知道我分析的对不对~初学，希望给位多加指正

Answer 15

这样可以的:
public static double toDouble(float f) {
                String s = f+"";
if (s != null && !"".equals(s.trim())) {
return Double.parseDouble(s);
}
return 0;
}