1.类图
- Float类中的静态属性存储在方法区中的静态区。
- 通过new Float()方法创建出来的对象存储在堆区。
在看Float前需要先了解IEEE 754标准，该标准定义了浮点数的格式还有一些特殊值，它规定了计算机中二进制与十进制浮点数转换的格式及方法。规定了四种表示浮点数值的方法，单精确度（32位）、双精确度（64位）、延伸单精确度（43位以上）与延伸双精确度（79位以上）。 多数编程语言支持单精确度和双精确度，该标准的全称为IEEE二进制浮点数算术标准（ANSI/IEEE Std 754-1985），又称IEC 60559:1989，微处理器系统的二进制浮点数算术（本来的编号是IEC 559:1989）。后来还有“与基数无关的浮点数”的“IEEE 854-1987标准”，有规定基数为2跟10的状况。最新标准是“ISO/IEC/IEEE FDIS 60559:2010”。 Float就是Java的单精度实现。
3.2 IEEE 754单精度浮点数表示浮点数由三部分组成，分别是符号位s、指数e和尾数f。
在IEEE754标准中，一个规格化的32位浮点数x的真值表示为 x = (−1)s∗(1.f)∗2(e−127) e = E - 127
其中尾数域所表示的值是1.f。由于规格化的浮点数的尾数域最左位（最高有效位）总是1，故这一位经常不予存储，而认为隐藏在小数点的左边。于是用23位字段可以存储24位有效数。
我们举个例子来看，二进制的“01000001001101100000000000000000”表示的浮点数是啥？
符号位为0，表示正数。
指数为“10000010”，减去127后为3。
尾数对应的值为“1.011011”。
于是最终得到浮点数为“1011.011”，转成十进制为“11.375”。
public final class Float extends Number implements Comparable<Float> {
// System.out.println(Float.POSITIVE_INFINITY == Float.intBitsTofloat(0x7f800000)); // true
// System.out.println(Float.POSITIVE_INFINITY); ==> Infinity
// 用来表示正无穷大，按照IEEE 754浮点标准规定，任何有限正数除以0为正无穷大，正无穷的值为0x7f800000。
public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
// System.out.println(Float.NEGATIVE_INFINITY == Float.intBitsToFloat(0xff800000)); // true
// System.out.println(Float.NEGATIVE_INFINITY); // -Infinity
// 用来表示负无穷大，任何有限负数除以0为负无穷的，负无穷的值为0xff800000。
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
// System.out.println(Float.isNAN(Float.intBitsToFloat(0x7fc00000))); // true
// System.out.println(Float.intBitsToFloat(0x7fc00000)); // NaN
// NaN 用来表示处理计算中出现的错误情况，比如0除以0或负数平方根。对于单精度浮点数，IEEE 标准规定 NaN 的指数域全为 1，且尾数域不等于零的浮点数。它并没有要求具体的尾数域，所以 NaN 实际上不非是一个，而是一族。Java这里定义的值为0x7fc00000。
public static final float NaN = 0.0f / 0.0f;
// System.out.println(Float.MAX_VALUE == Float.intBitsToFloat(0x7f7fffff)); // true
// System.out.println(Float.intBitsToFloat(0x7f7fffff)); // 3.4028235E38
// 用来表示最大的浮点数值，它定义为0x1.fffffeP 127f，这里0x表示十六进制，1.fffffe表示十六进制的小数，P表示2， 表示几次方，这里就是2的127次方，最后的f是转成浮点型。所以最后最大值为3.4028235E38。
public static final float MAX_VALUE = 0x1.fffffeP 127f; // 3.4028235e 38f
// System.out.println(Float.MIN_NORMAL == Float.intBitsToFloat(0x00800000)); // true
// System.out.println(Float.intBitsToFloat(0x00800000)); // 1.17549435E-38
// 1.6开始存在
// 用来表示最小标准值，它定义为0x1.0p-126f，这里其实就是2的-126次方的了，值为1.17549435E-38f。
public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f
// System.out.println(Float.MIN_VALUE == Float.intBitsToFloat(0x1)); // true
// System.out.println(Float.intBitsToFloat(0x1)); // 1.4E-45
// 用来表示浮点数最小值，它定义为0x0.000002P-126f，最后的值为1.4e-45f
public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f
// System.out.println(Math.getExponent(Float.MAX_VALUE) == Float.MAX_EXPONENT); // true
// System.out.println(Math.getExponent(Float.MAX_VALUE)); // 127
// 1.6开始
// 用来表示指数的最大值，这里定为127，这个也是按照IEEE 754浮点标准的规定。
public static final int MAX_EXPONENT = 127;
// System.out.println(Math.getExponent(Float.MIN_NORMAL) == Float.MIN_EXPONENT); // true
// System.out.println(Float.MIN_EXPONENT); // -126
// 1.6开始
// 用来表示指数的最小值，按照IEEE 754浮点标准的规定，它为-126。
public static final int MIN_EXPONENT = -126;
// 用来表示二进制float值的比特数，值为32，静态变量且不可变。
public static final int SIZE = 32;
// 用来表示二进制float值的字节数，值为SIZE除于Byte.SIZE，结果为4字节，表示存储一个Float类型的变量占用4字节。
public static final int BYTES = SIZE / Byte.SIZE;
}
Float构造方法有3个，第一个是将float但精度浮点数转为Float值，第二个是将double值的双精度浮点数转为单精度浮点数，该转化可能出现精度丢失的情况。 第三个构造方法是将字符串转为单精度浮点数。
public final class Float extends Number implements Comparable<Float> {
public Float(float value) {
this.value = value;
}
public Float(double value) {
this.value = (float)value;
}
public Float(String s) throws NumberFormatException {
value = parseFloat(s);
}
}
- 该方法是将浮点数转为16进制数的字符串
public final class Float extends Number implements Comparable<Float> {
public static String toHexString(float f) {
if (Math.abs(f) < FloatConsts.MIN_NORMAL
&& f != 0.0f ) {// float subnormal
// Adjust exponent to create subnormal double, then
// replace subnormal double exponent with subnormal float
// exponent
String s = Double.toHexString(Math.scalb((double)f,
/* -1022 126 */
DoubleConsts.MIN_EXPONENT-
FloatConsts.MIN_EXPONENT));
return s.replaceFirst("p-1022$", "p-126");
}
else // double string will be the same as float string
return Double.toHexString(f);
}
}
public class FloatDemoTest {
@Test
public void testToHexString() {
System.out.println(Float.toHexString(1.0f)); //0x1.0p0
}
}
改方法有两个，一个是将字符串转为单精度浮点数，一个是将float值转化为Float对象
public final class Float extends Number implements Comparable<Float> {
public static Float valueOf(String s) throws NumberFormatException {
return new Float(parseFloat(s));
}
public static Float valueOf(float f) {
return new Float(f);
}
}
public class FloatDemoTest {
@Test
public void testValueOf() {
System.out.println(Float.valueOf(1.01f)); // 1.01
System.out.println(Float.valueOf("1.01")); // 1.01
System.out.println(Float.valueOf(" 1.01f")); // 1.01
System.out.println(Float.valueOf("-1.01f")); // -1.01
System.out.println(Float.valueOf("1.01F")); // 1.01
System.out.println(Float.valueOf("1.01d")); // 1.01
System.out.println(Float.valueOf("1.01I")); // java.lang.NumberFormatException: For input string: "1.01I"
}
}
该是Java中的内置方法，该方法返回一个新的float，该新float初始化为指定的String表示的值，这由Float类的valueOf方法完成。
public final class Float extends Number implements Comparable<Float> {
public static float parseFloat(String s) throws NumberFormatException {
return FloatingDecimal.parseFloat(s);
}
}
- 该方法是判断是否是非数字的值(NAN)， NaN是Not a Number的缩写。
public final class Float extends Number implements Comparable<Float> {
public boolean isNaN() {
return isNaN(value);
}
public static boolean isNaN(float v) {
return (v != v);
}
}
- isInfinite()方法用于检查此Float对象的无穷大(即正无穷大或负无穷大)
- isFinite() 方法如果传递的参数是有限浮点数，则返回 true，否则返回 false(在 NaN 和无穷大参数的情况下)。
public final class Float extends Number implements Comparable<Float> {
public static boolean isInfinite(float v) {
return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
}
public static boolean isFinite(float f) {
return Math.abs(f) <= FloatConsts.MAX_VALUE;
}
}
public class FloatDemoTest {
@Test
public void testInfiniteAndFinite() {
System.out.println(Float.isInfinite(Float.POSITIVE_INFINITY)); // true
System.out.println(Float.isInfinite(0.05f)); // false
System.out.println(Float.isFinite(0.05f)); // true
System.out.println(Float.isFinite(Float.POSITIVE_INFINITY)); // false
}
}
Float类中的floatToIntBits()方法是Java中的内置函数，它根据IEEE 754浮点“single format”位布局返回指定浮点值的表示形式。
返回值：该函数返回表示浮点数的整数位。以下是特殊情况：
- 如果参数为正无穷大，则结果为0x7f800000。
- 如果参数为负无穷大，则结果为0xff800000。
- 如果参数为NaN，则结果为0x7fc00000。
public final class Float extends Number implements Comparable<Float> {
public static int floatToIntBits(float value) {
int result = floatToRawIntBits(value);
// Check for NaN based on values of bit fields, maximum
// exponent and nonzero significand.
if ( ((result & FloatConsts.EXP_BIT_MASK) ==
FloatConsts.EXP_BIT_MASK) &&
(result & FloatConsts.SIGNIF_BIT_MASK) != 0)
result = 0x7fc00000;
return result;
}
}
- sum方法是用来计算两个float值之和。
- max方法是用来查找两个float值的最大值。
- min方法是用来查找两个float值的最小值。
public final class Float extends Number implements Comparable<Float> {
public static float sum(float a, float b) {
return a b;
}
public static float max(float a, float b) {
return Math.max(a, b);
}
public static float min(float a, float b) {
return Math.min(a, b);
}
}
- Float类中的floatToRawIntBits()方法是Java中的内置函数，该函数根据IEEE 754浮点“single format”位布局返回指定浮点值的表示形式，并保留Not-a-Number(NaN)值。
返回值：该函数返回代表浮点数的位。但是，有3种特殊情况：
* 如果参数为正无穷大，则结果为0x7f800000。
* 如果参数为负无穷大，则结果为0xff800000。
* 如果参数为NaN，则结果为0x7fc00000。
- Java Float 类的 intBitsToFloat() 方法返回与给定位表示相关的浮点值。根据 IEEE 754 浮点 'single format' 位布局，传递的参数被视为浮点值的表示。
此方法返回具有相同位模式的浮点值。
* 如果传递的参数为 0X7f800000，则返回的结果为正无穷大。
* 如果传递的参数为 0Xff800000，则返回的结果为负无穷大。
* 如果传递的参数在 0x7f800001 到 0x7fffffff 之间的范围内或在 0xff800001 到 0xffffffff 之间的范围内，则返回的结果为 Nan。
public final class Float extends Number implements Comparable<Float> {
public static native int floatToRawIntBits(float value);
public static native float intBitsToFloat(int bits);
}
- 需要精确计算时不要使用float和double，如果需要精度计算，请使用BigDecimal
- 不能用浮点数作为循环变量,浮点数不能为循环因子，精度问题会导致 (float)2000000000 == 2000000050为true
- 浮点型数据判断相等不能直接使用,应采用如下方式
float a =...;
float b =...;
if (Math.abs(a-b) < 1E-6f) {
...
}
