java Float和Double 之间的相互转型问题

由于float 是单精度浮点小数,而double 是双精度浮点小数

单精度型能精确到七位,而双精度能精确到15位。用户在选用这些数据类型时,要注意变量所取值的范围。并且数值为整数时,为了运算速度,不用把变量硬定义为浮点型。

如果要将Float和Double之间相互转型,java 提供了一下方法Float.doubleValue()和Double.floatValue()

查看JDK1.6中对其方法进行这样解释

Float.doubleValue()

public double doubleValue()
返回此 Float 对象的 double 值。
指定者:
Number 中的
doubleValue
返回:
此对象表示的 float 值被转换为 double 类型,并返回转换的结果。

Double.floatValue()

public float floatValue()
返回此 Double 对象的 float 值。
指定者:
Number 中的
floatValue
返回:
转换为 float 类型的由此对象所表示的 double
从以下版本开始:
JDK1.0

先从一个简单的例子进行说明一下:

public static void main(String[] args) {
		Float f=new Float(14.1);
		System.out.println(f.floatValue());
		System.out.println(f.doubleValue());

		Double d = new Double(14.1);
		System.out.println(d.floatValue());
		System.out.println(d.doubleValue());
	}

输出的结果是:

14.1
14.100000381469727
14.1
14.1

这时,可以看到Float.doubleValue()时,数字是不准确的,应该是14.1,而结果14.10000381469727,这就是单精度转双精度的时候,双精度会对单精度进行补位。导致出现偏差。

我这时的解决办法是这样的

Float f=new Float(14.1);
System.out.println(f.floatValue());
System.out.println(f.doubleValue());
System.out.println(Double.parseDouble(f.floatValue()+""));

输出的结果

14.1
14.100000381469727
14.1

再看下一个例子

	public static void main(String[] args) {
		Float f=new Float(14.111111111111111111111111);
		System.out.println(f.floatValue());
		System.out.println(f.doubleValue());

		Double d = new Double(14.111111111111111111111111);
		System.out.println(d.floatValue());
		System.out.println(d.doubleValue());
	}

输出结果:

14.111111
14.11111068725586
14.111111
14.11111111111111

这时,由于小数点后面的位数过长,Float单精度和Double双精度都进行一次截位后进行计算,这时,Float.doubleValue()仍然出现补位问题,但是这次补位已经将原有数据给破坏掉了。

为了减少误差,将Float的数据转换成double数据时,还是采取上一个操作办法

System.out.println(Double.parseDouble(f.floatValue()+""));

输出的结果是

14.111111

再看下面的例子

	public static void main(String[] args) {
		Float f=new Float(14.6666666666666666666666666666666666666);
		System.out.println(f.floatValue());
		System.out.println(f.doubleValue());

		System.out.println(Double.parseDouble(f.floatValue()+""));

		Double d = new Double(14.6666666666666666666666666666666666666);
		System.out.println(d.floatValue());
		System.out.println(d.doubleValue());
	}

输出的结果是

14.666667
14.666666984558105
14.666667
14.666667
14.666666666666666

这时会发现当给出的数据超出单精度的位数时,会截取,截取后的数字剩下的第一位大于5时,必然进位(即最后一位+1),小于5时,必然不进位(即最后一位不变)。

而截取后的数字剩下的第一位等于5时,有时会进位,有时会不进位。(查看源码,未找出原因)

双精度在此数值时未进位

再看下面的例子

	public static void main(String[] args) {
		Float f=new Float(14.777777777777777777777777);
		System.out.println(f.floatValue());
		System.out.println(f.doubleValue());

		System.out.println(Double.parseDouble(f.floatValue()+""));

		Double d = new Double(14.77777777777777777777777777777);
		System.out.println(d.floatValue());
		System.out.println(d.doubleValue());
	}

这时的结果

14.777778
14.777777671813965
14.777778
14.777778
14.777777777777779

所以在大量数据的测试下,发现不管是单精度还是双精度准确的进位是无法确定的。

总结

在单精度转双精度的时候未防止补位问题采用

Double.parseDouble(f.floatValue()+"")

以保留单精度数据的准确性

而在双精度转单精度的时候,未发现错误的数据。基本可以和单精度是一样的。

终于写完了。。。。此文章主要是写给新手们看的。。。如有更好的解决办法可以直接评论。。。。。以便大家学习。。。。。

时间: 2024-11-05 19:02:38

java Float和Double 之间的相互转型问题的相关文章

java float跟double类型区别

单精度和双精度的取值范围和精度是不同的 单精度:float的精度是6位有效数字,取值范围是10的-38次方到10的38次方,float占用4字节空间 双精度:double的精度是15位有效数字,取值范围是10的-308次方到10的308次方,double占用8字节空间. 原文地址:https://www.cnblogs.com/mileSs/p/8386968.html

Java中浮点型数据Float和Double进行精确计算的问题

一.浮点计算中发生精度丢失  大概很多有编程经验的朋友都对这个问题不陌生了:无论你使用的是什么编程语言,在使用浮点型数据进行精确计算时,你都有可能遇到计算结果出错的情况.来看下面的例子. // 这是一个利用浮点型数据进行精确计算时结果出错的例子,使用Java编写,有所省略. double a = (1.2 - 0.4) / 0.1;System.out.println(a); 如果你认为这个程序的输出结果是“8”的话,那你就错了.实际上,程序的输出结果是“7.999999999999999”.好

【转】JAVA程序中Float和Double精度丢失问题

原文网址:http://blog.sina.com.cn/s/blog_827d041701017ctm.html 问题提出:12.0f-11.9f=0.10000038,"减不尽"为什么? 来自MSDN的解释: http://msdn.microsoft.com/zh-cn/c151dt3s.aspx 为何浮点数可能丢失精度浮点十进制值通常没有完全相同的二进制表示形式. 这是 CPU 所采用的浮点数据表示形式的副作用.为此,可能会经历一些精度丢失,并且一些浮点运算可能会产生意外的结果

Java浮点数float和double精确计算的精度误差问题总结

1.float整数计算误差 案例:会员积分字段采用float类型,导致计算会员积分时,7位整数的数据计算结果出现误差. 原因:超出float精度范围,无法精确计算. float和double的精度是由尾数的位数来决定的.浮点数在内存中是按科学计数法来存储的,其整数部分始终是一个隐含着的“1”,由于它是不变的,故不能对精度造成影响. float:2^23 = 8388608,一共七位,这意味着最多能有7位有效数字,但绝对能保证的为6位,也即float的精度为6~7位有效数字: double:2^5

Java中的简单浮点数类型float和double不能够进行精确运算

在java中,简单的浮点类型float和double是不能够进行运算.我们先看下面的两个程序代码: 代码一: import java.util.Scanner; class Circle { double radius; static final double PI=3.14; public Circle(){this.radius=0;} public Circle(double r){this.radius=r;} public double getArea(){return PI*this

Java 浮点数 float或double类型的表示范围和精度

隐约记得,浮点数判断大小好像有陷阱,因为底层的二进制数不能精确表示所有的小数.有时候会产生让人觉得莫名其妙的事情. 如在java中, 0.99999999f==1f //true 0.9f==1f //false 要明白这些,首先要搞清楚float和double在内存结构 1.内存结构 float和double的范围是由指数的位数来决定的. float的指数位有8位,而double的指数位有11位,分布如下: float: 1bit(符号位) 8bits(指数位) 23bits(尾数位) dou

java控制float和double的精度

在做读取Excel表格数据时,碰到有小数点的数字,用double和float来求和时会多出好多位小数,看起来总觉得怪怪的,怎样控制它的长度呢? DecimalFormat df = new DecimalFormat("########.0"); //四舍五入 value = Double.parseDouble(df.format(value)); 我这里是控制一位小数,如果要求两位,就写成########.00 java控制float和double的精度,布布扣,bubuko.co

java中int,float,long,double取值范围,内存泄露

java中int,float,long,double取值范围是多少? 写道 public class TestOutOfBound { public static void main(String[] args) { System.out.println(Integer.MAX_VALUE-(-Integer.MAX_VALUE)); //内存溢出System.out.println(Integer.MAX_VALUE); //2的31次方-1,10个数位,正的20亿左右,用在钱上面不一定够Sy

java基础之float、double底层运算

目前java遵照IEEE制定的浮点数表示法来进行float,double运算.这种结构是一种科学计数法,用符号.指数和尾数来表示,底数定为2--即把一个浮点数表示为尾数乘以2的指数次方再添上符号. 我们来看一段java代码: public class FloatToBinary { public static void main(String[] args) { float f1=8.5f; System.out.println("f1底层数据(十进制):"+Float.floatTo