Float源码

看Double就够了，几乎是一样的，Double中全一些https://blog.youkuaiyun.com/qq_26896085/article/details/94733615

package java.lang;
import sun.misc.FloatingDecimal;
import sun.misc.FloatConsts;
import sun.misc.DoubleConsts;
public final class Float extends Number implements Comparable<Float> {
    // float的最大值。 它等于Float.intBitsToFloat(0x7f800000)返回的值。
    public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
    // float的最小值。 它等于Float.intBitsToFloat(0xff800000)返回的值。 
    public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
    // float类型的Not-a-Number值的常量。 它相当于返回的值Float.intBitsToFloat(0x7fc00000)
    public static final float NaN = 0.0f / 0.0f;
    // 最大正的有限值float 
    public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f
    // 最小正正常值
    public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f
    // 最小的正非零值类型float 
    public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f
    // 归一化float变量可能具有的最大指数
    public static final int MAX_EXPONENT = 127;
    // 归一化float变量可能具有的最小指数
    public static final int MIN_EXPONENT = -126;
    // 32字节 --> 8位
    public static final int SIZE = 32;
    // 用于表示 float值的字节数。
    public static final int BYTES = SIZE / Byte.SIZE;
    // 类原始类型 float的 类实例
    @SuppressWarnings("unchecked")
    public static final Class<Float> TYPE = (Class<Float>) Class.getPrimitiveClass("float");
    
    // 将字符数据f转换成字符串
    public static String toString(float f) {
        // sun包下面的源码，一般看不到
        return FloatingDecimal.toJavaFormatString(f);
    }
    
    // 将float数据，转换成16进制
    public static String toHexString(float f) {
        if (Math.abs(f) < FloatConsts.MIN_NORMAL
            &&  f != 0.0f ) {
            // 调用的是Double中的实现方法，具体看Double源码
            String s = Double.toHexString(Math.scalb((double)f,
                                                     DoubleConsts.MIN_EXPONENT-
                                                     FloatConsts.MIN_EXPONENT));
            return s.replaceFirst("p-1022$", "p-126");
        }
        else // double string与float string相同
            return Double.toHexString(f);
    }
    
    // 将数字字符串转化的float, 并返回新的Float对象
    public static Float valueOf(String s) throws NumberFormatException {
        return new Float(parseFloat(s));
    }
    
    // 获取float值
    public static Float valueOf(float f) {
        return new Float(f);
    }

    // 将数字字符串转化的float
    public static float parseFloat(String s) throws NumberFormatException {
        return FloatingDecimal.parseFloat(s);
    }
    
    // 是否是nan,永远为false
    public static boolean isNaN(float v) {
        return (v != v);
    }
    
    // 是否是无限的float
    public static boolean isInfinite(float v) {
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
    }
    // 是否是无限的float
    public static boolean isFinite(float f) {
        // f的绝对值大于float定义的中最大值，
        return Math.abs(f) <= FloatConsts.MAX_VALUE;
    }
    
    // 定义变量用来接收float值
    private final float value;
    
    // 构造函数，传入一个value
    public Float(float value) {
        this.value = value;
    }
    // 构造函数，传入一个double值
    public Float(double value) {
        this.value = (float)value;
    }
    // 构造函数，传入一个字符串
    public Float(String s) throws NumberFormatException {
        value = parseFloat(s);
    }
    
    // 判断是否是nan,这里永远为false
    public boolean isNaN() {
        return isNaN(value);
    }
    
    // 是否是无限的
    public boolean isInfinite() {
        return isInfinite(value);
    }
    // 将float数据转换成其它类型的数据
    public String toString() {
        return Float.toString(value);
    }
    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;
    }
    
    // 获取hashCode值
    @Override
    public int hashCode() {
        return Float.hashCode(value);
    }
    
    // 计算hashCode值
    public static int hashCode(float value) {
        return floatToIntBits(value);
    }
    
    // 比较两个float数据的大小
    public boolean equals(Object obj) {
        return (obj instanceof Float)
               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
    }
    
    // 将falot转换成int的byte值
    public static int floatToIntBits(float value) {
        int result = floatToRawIntBits(value);
        // 根据位字段，最大指数和非零有效数的值检查NaN。
        if ( ((result & FloatConsts.EXP_BIT_MASK) ==
              FloatConsts.EXP_BIT_MASK) &&
             (result & FloatConsts.SIGNIF_BIT_MASK) != 0)
            result = 0x7fc00000;
        return result;
    }
    
    // ?????????????????
    public static native int floatToRawIntBits(float value);
    public static native float intBitsToFloat(int bits);
    
    // 比较两个float数据
    public int compareTo(Float anotherFloat) {
        return Float.compare(value, anotherFloat.value);
    }
    
    // 比较两个float数据
    public static int compare(float f1, float f2) {
        if (f1 < f2)
            return -1;// val都不是NaN，this.value更小
        if (f1 > f2)
            return 1;// val都不是NaN，this.value更大
        // 由于NaNs的可能性，不能使用floatToRawIntBits。
        int thisBits    = Float.floatToIntBits(f1);
        int anotherBits = Float.floatToIntBits(f2);
        return (thisBits == anotherBits ?  0 : // Values are equal
                (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
                 1));                          // (0.0, -0.0) or (NaN, !NaN)
    }
    // 求和
    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);
    }
    private static final long serialVersionUID = -2671257302660747028L;
}