关于IEEE 754
在看Float前需要先了解IEEE 754标准，该标准定义了浮点数的格式还有一些特殊值，它规定了计算机中二进制与十进制浮点数转换的格式及方法。规定了四种表示浮点数值的方法，单精确度（32位）、双精确度（64位）、延伸单精确度（43位以上）与延伸双精确度（79位以上）。多数编程语言支持单精确度和双精确度，这里讨论的Float就是Java的单精确度的实现。
浮点数的表示
浮点数由三部分组成，如下图，符号位s、指数e和尾数f。
对于求值我们是有一个公式对应的，根据该公式来看会更简单点，某个浮点数的值为：
可以看到32位的最高位为符号标识符，1表示负数，0表示正数。指数部分为8位，其实可以是0到255，但是为了可正可负，这里需要减去127后才是真正的指数，而底数固定为2。剩下的23位表示尾数，但默认前面都会加上1.。所以通过上面就可以将一个浮点数表示出来了。
我们举个例子来看，二进制的“01000001001101100000000000000000”表示的浮点数是啥？
符号位为0，表示正数。
指数为“10000010”，减去127后为3。
尾数对应的值为“1.011011”。
于是最终得到浮点数为“1011.011”，转成十进制为“11.375”。
Float概况
Java的Float类主要的作用就是对基本类型float进行封装，提供了一些处理float类型的方法，比如float到String类型的转换方法或String类型到float类型的转换方法，当然也包含与其他类型之间的转换方法。
继承结构
--java.lang.Object
--java.lang.Number
--java.lang.Float
主要属性
public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
public static final float NaN = 0.0f / 0.0f;
public static final float MAX_VALUE = 0x1.fffffeP+127f;
public static final float MIN_NORMAL = 0x1.0p-126f;
public static final float MIN_VALUE = 0x0.000002P-126f;
public static final int MAX_EXPONENT = 127;
public static final int MIN_EXPONENT = -126;
public static final int SIZE = 32;
public static final int BYTES = SIZE / Byte.SIZE;
public static final Class<Float> TYPE = (Class<Float>) Class.getPrimitiveClass("float");
POSITIVE_INFINITY用来表示正无穷大，按照IEEE 754浮点标准规定，任何有限正数除以0为正无穷大，正无穷的值为0x7f800000。NEGATIVE_INFINITY用来表示负无穷大，任何有限负数除以0为负无穷的，负无穷的值为0xff800000。NaN用来表示处理计算中出现的错误情况，比如0除以0或负数平方根。对于单精度浮点数，IEEE 标准规定 NaN 的指数域全为 1，且尾数域不等于零的浮点数。它并没有要求具体的尾数域，所以 NaN 实际上不非是一个，而是一族。Java这里定义的值为0x7fc00000。MAX_VALUE用来表示最大的浮点数值，它定义为0x1.fffffeP+127f，这里0x表示十六进制，1.fffffe表示十六进制的小数，P表示2，+表示几次方，这里就是2的127次方，最后的f是转成浮点型。所以最后最大值为3.4028235E38。MIN_NORMAL用来表示最小标准值，它定义为0x1.0p-126f，这里其实就是2的-126次方的了，值为1.17549435E-38f。MIN_VALUE用来表示浮点数最小值，它定义为0x0.000002P-126f，最后的值为1.4e-45f。MAX_EXPONENT用来表示指数的最大值，这里定为127，这个也是按照IEEE 754浮点标准的规定。MIN_EXPONENT用来表示指数的最小值，按照IEEE 754浮点标准的规定，它为-126。SIZE用来表示二进制float值的比特数，值为32，静态变量且不可变。BYTES用来表示二进制float值的字节数，值为SIZE除于Byte.SIZE，结果为4。TYPE的toString的值是float。
Class的getPrimitiveClass是一个native方法，在Class.c中有个Java_java_lang_Class_getPrimitiveClass方法与之对应，所以JVM层面会通过JVM_FindPrimitiveClass函数根据”float”字符串获得jclass，最终到Java层则为Class<Float>。
JNIEXPORT jclass JNICALL
Java_java_lang_Class_getPrimitiveClass(JNIEnv *env,
jclass cls,
jstring name)
{
const char *utfName;
jclass result;
if (name == NULL) {
JNU_ThrowNullPointerException(env, 0);
return NULL;
}
utfName = (*env)->GetStringUTFChars(env, name, 0);
if (utfName == 0)
return NULL;
result = JVM_FindPrimitiveClass(env, utfName);
(*env)->ReleaseStringUTFChars(env, name, utfName);
return result;
}
当TYPE执行toString时，逻辑如下，则其实是getName函数决定其值，getName通过native方法getName0从JVM层获取名称，
public String toString() {
return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
+ getName();
}
getName0根据一个数组获得对应的名称，JVM根据Java层的Class可得到对应类型的数组下标，比如这里下标为6，则名称为”float”。
const char* type2name_tab[T_CONFLICT+1] = {
NULL,
NULL,
NULL,
NULL,
"boolean",
"char",
"float",
"double",
"byte",
"short",
"int",
"long",
"object",
"array",
"void",
"*address*",
"*narrowoop*",
"*conflict*"
};
主要方法
parseFloat
public static float parseFloat(String s) throws NumberFormatException {
return FloatingDecimal.parseFloat(s);
}
通过调用FloatingDecimal的parseFloat方法来实现对字符串的转换，FloatingDecimal类主要提供了对 IEEE-754，该方法的实现代码实在是太长，这里不再贴出了，说下它的处理思想及步骤。
1. 判断开头是否为“-”或“+”符号，即正数或负数。
2. 判断是不是一个NaN，如果是则返回NaN。
3. 判断是不是一个Infinity，如果是则返回Infinity。
4. 判断是不是一个0x开头的十六进制的Java浮点数，如果是则将该十六进制浮点数按照IEEE-754标准转换成十进制浮点数。比如字符串为 0x12.3512p+11f ，则转换后为37288.562。
5. 判断字符串中是否有包含了E字符，即是否是科学计数法，如果有则需要处理。比如字符串为 10001.222E+2 ，则转换后为1000122.2。
6. 还要处理浮点数精度问题，这个处理比较复杂，我们知道浮点数的精度是7位有效数字，这里为什么是7呢？还要回到IEEE-754标准上，32位二进制转换成浮点数是根据公式$(-1)^s*(1.f)*2^{(e-127)}$转换的，可以看到它的精度由尾数来决定，尾数有23位，那么$2^{23}=8388608$，该值介于$10^{6}$到$10^{7}$，所以它能保证6位精确的数，但是7位就不一定了，这里是相对小数点来说的，所以对应整个浮点型的精确值为有效位数就是7位，8位的不一定能准确表示。这里对比几个例子，字符串30.200019转换后为30.20002，一共七位有效位；字符串30.200001转换后为30.2，一共七位有效位，但后面都为0，所以省略；字符串30000.2196501转换后为30000.219，一共八位有效位，刚好能准确表示八位。
构造函数
public Float(String s) throws NumberFormatException {
value = parseFloat(s);
}
public Float(float value) {
this.value = value;
}
public Float(double value) {
this.value = (float)value;
}
提供三种构造函数，都比较简单，可传入String、float和double类型值，其中String类型会调用parseFloat方法进行转换，double则直接转成float类型。
toString
public String toString() {
return Float.toString(value);
}
public static String toString(float f) {
return FloatingDecimal.toJavaFormatString(f);
}
两个toString方法，主要看第二个，通过FloatingDecimal类的toJavaFormatString方法转成字符串。这个转换过程也是比较复杂，这里不再贴代码，它处理的过程是先将浮点数转成IEEE-754标准的二进制形式，并且还要判断是否是正负无穷大，是否是NaN。然后再按照IEEE-754标准从二进制转换成十进制，此过程十分复杂，需要考虑的点相当多。最后生成浮点数对应的字符串。
valueOf方法
public static Float valueOf(float f) {
return new Float(f);
}
public static Float valueOf(String s) throws NumberFormatException {
return new Float(parseFloat(s))
}
有两个valueOf方法，对于float型的直接new一个Float对象返回，而对于字符串则先调用parseFloat方法转成float后再new一个Float对象返回。
xxxValue方法
public byte byteValue() {
return (byte)value;
}
public short shortValue() {
return (short)value;
}
public int intValue() {
return (int)value;
}
public long longValue() {
return (long)value;
}
public float floatValue() {
return value;
}
public double doubleValue() {
return (double)value;
}
包括byteValue、shortValue、intValue、longValue、floatValue和doubleValue等方法，其实就是转换成对应的类型。
floatToRawIntBits方法
public static native int floatToRawIntBits(float value);
JNIEXPORT jint JNICALL
Java_java_lang_Float_floatToRawIntBits(JNIEnv *env, jclass unused, jfloat v)
{
union {
int i;
float f;
} u;
u.f = (float)v;
return (jint)u.i;
}
floatToRawIntBits是一个本地方法，该方法主要是将一个浮点数转成IEEE 754标准的二进制形式对应的整型数。对应的本地方法的处理逻辑简单而且有效，就是通过一个union实现了int和float的转换，最后再转成java的整型jint。
floatToIntBits方法
public static native float intBitsToFloat(int bits);
JNIEXPORT jfloat JNICALL
Java_java_lang_Float_intBitsToFloat(JNIEnv *env, jclass unused, jint v)
{
union {
int i;
float f;
} u;
u.i = (long)v;
return (jfloat)u.f;
}
该方法与floatToRawIntBits方法对应，floatToIntBits同样是一个本地方法，该方法主要是将一个IEEE 754标准的二进制形式对应的整型数转成一个浮点数。可以看到其本地实现也是通过union来实现的，完成int转成float，最后再转成java的浮点型jfloat。
floatToIntBits方法
public static int floatToIntBits(float value) {
int result = floatToRawIntBits(value);
if ( ((result & FloatConsts.EXP_BIT_MASK) == FloatConsts.EXP_BIT_MASK) &&
(result & FloatConsts.SIGNIF_BIT_MASK) != 0)
result = 0x7fc00000;
return result;
}
该方法主要先通过调用floatToRawIntBits获取到IEEE 754标准对应的整型数，然后再分别用FloatConsts.EXP_BIT_MASK和FloatConsts.SIGNIF_BIT_MASK两个掩码去判断是否为NaN，0x7fc00000对应的即为NaN。
hashCode方法
public int hashCode() {
return Float.hashCode(value);
}
public static int hashCode(float value) {
return floatToIntBits(value);
}
主要看第二个hashCode方法即可，它是通过调用floatToIntBits来实现的，所以它返回的哈希码其实就是某个浮点数的IEEE 754标准对应的整型数。
isFinite 和 isInfinite
public static boolean isFinite(float f) {
return Math.abs(f) <= FloatConsts.MAX_VALUE;
}
public static boolean isInfinite(float v) {
return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
}
这两个方法分别用于判断一个浮点数是否为有穷数或无穷数。逻辑很简单，绝对值小于FloatConsts.MAX_VALUE的数则为有穷数，FloatConsts.MAX_VALUE的值为3.4028235e+38f，它其实与前面Float类中定义的MAX_VALUE相同。而是否为无穷数则通过POSITIVE_INFINITY和NEGATIVE_INFINITY进行判断。
isNaN方法
public static boolean isNaN(float v) {
return (v != v);
}
用于判断是个浮点数是否为NaN,该方法逻辑很简单，直接(v != v)，为啥能这样做？因为规定一个NaN与任何值都不相等，包括它自己。所以这部分逻辑在JVM或本地中会做，于是可以直接通过比较来判断。
max 和 min方法
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);
}
用于获取两者较大或较小值，直接交由Math类完成。
compare方法
public static int compare(float f1, float f2) {
if (f1 < f2)
return -1;
if (f1 > f2)
return 1;
int thisBits = Float.floatToIntBits(f1);
int anotherBits = Float.floatToIntBits(f2);
return (thisBits == anotherBits ? 0 : (thisBits < anotherBits ? -1 : 1));
}
f1小于f2则返回-1，反之则返回1。无法通过上述直接比较时则使用floatToIntBits方法分别将f1和f2转成IEEE 754标准对应的整型数，然后再比较。相等则返回0，否则返回-1或1。
以下是广告和相关阅读
========广告时间========
鄙人的新书《Tomcat内核设计剖析》已经在京东销售了，有需要的朋友可以到 https://item.jd.com/12185360.html 进行预定。感谢各位朋友。
=========================
相关阅读：
从JDK源码角度看Object
从JDK源码角度看Long
从JDK源码角度看Integer
volatile足以保证数据同步吗
谈谈Java基础数据类型
从JDK源码角度看并发锁的优化
从JDK源码角度看线程的阻塞和唤醒
从JDK源码角度看并发竞争的超时
从JDK源码角度看java并发线程的中断
从JDK源码角度看Java并发的公平性
从JDK源码角度看java并发的原子性如何保证
从JDK源码角度看Byte
从JDK源码角度看Boolean
从JDK源码角度看Short