包装类之Float源码分析

包装类Float源码分析：（Double同理）

java float类型用IEEE754标准规定
float类型占4个字节(32位)，其中包括1位的符号位，8位的指数位，和23位的小数位
（对于double双精度浮点数，用 1 位表示符号，用 11 位表示指数，52 位表示尾数，其中指数域称为阶码。）

类声明：(与其他包装类类似)

public final class Float extends Number implements Comparable<Float> 

成员：

1.POSITIVE_INFINITY/NEGATIVE_INFINITY :正无穷大(Infinity)/负无穷大(-Infinity)

 public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
 public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;

说明：这是java的规定，没必要深究为什么1.0/0.0不报错，不过1/0肯定报错

2.NaN：Not a Number(不是数)（输出就是NaN）

public static final float NaN = 0.0f / 0.0f;

3.MAX_VALUE/MIN_VALUE :最大最小值，以16进制形式+科学计数法表示，后面有10进制+科学计数法的注释

public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f
public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f

4.MAX_EXPONENT/MIN_EXPONENT :指数部分的最大值（指数位的长度1个字节）：127,最小值为-126

public static final int MAX_EXPONENT = 127;
public static final int MIN_EXPONENT = -126;

5.SIZE :一个float占4个字节（32位）

public static final int SIZE = 32;

6.TYPE :FLoat对应的基本类型为float

 public static final Class<Float> TYPE = Class.getPrimitiveClass("float");

7.value:每个Float对应的float

 private final float value;

类方法：

1.toString(float f):

 public static String toString(float f) {
    return new FloatingDecimal(f).toJavaFormatString();
    }

FloatingDecimal：的作用是将float格式化转换，即什么时候用数字显示(位数小于8位),什么时候用指数显示(位数>=8位)
更加详细的在API中有说明

2.toHexString(float f):转成16进制的字符串（用科学计数法表示）

 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(FpUtils.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);
    }

3.两个valueOf():将字符串/浮点数转换成Float类型的对象

 public static Float valueOf(String s) throws NumberFormatException {
    return new Float(FloatingDecimal.readJavaFormatString(s).floatValue());
    }

 public static Float valueOf(float f) {
        return new Float(f);
    }

4.parseFloat(String s):和valueOf重复了

public static float parseFloat(String s) throws NumberFormatException {
    return FloatingDecimal.readJavaFormatString(s).floatValue();
    }

5.isNaN(float v)：判断是不是一个‘不是数’(NaN和任何东西都不想等，包括他自己)

static public boolean isNaN(float v) {
    return (v != v);
    }

6.isInfinite(float v):判断是不是正无穷或者负无穷（这两个数使计算没有任何意义）

static public boolean isInfinite(float v) {
    return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
    }

7.floatToRawIntBits(float value) floatToIntBits(float value) intBitsToFloat(int bits)：

• 根据 IEEE 754 的浮点“单一形式”中的位布局，返回指定浮点值的表示形式
• 根据 IEEE 754 的浮点“单一形式”中的位布局，返回指定浮点值的表示形式，并保留非数字 (NaN) 值。
• 返回对应于给定的位表示形式的 float 值。该参数被认为是符合 IEEE 754 的浮点“单一形式”中的位布局规定的浮点值表示形式

 public static native float intBitsToFloat(int bits);
 public static native int floatToRawIntBits(float value);
 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;
    }

8.compare(float f1, float f2):比较两个float的大小

  public static int compare(float f1, float f2) {
       if (f1 < f2)
            return -1;       // Neither val is NaN, thisVal is smaller
        if (f1 > f2)
            return 1;        // Neither val is NaN, thisVal is larger

        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)
    }

这两个数相加位NaN,相乘为负无穷

构造器：

1.Float(float value)：

public Float(float value) {
    this.value = value;
    }

2.Float(double value):用double强转

public Float(double value) {
    this.value = (float)value;
    }

1. Float(String s):用字符串初始化

public Float(String s) throws NumberFormatException {
    // REMIND: this is inefficient
    this(valueOf(s).floatValue());
    }

方法（对成员value的操作）

1. isNaN()：是不是一个’数’

 public boolean isNaN() {
    return isNaN(value);
    }

2.isInfinite():是不是正无穷或者负无穷

public boolean isInfinite() {
    return isInfinite(value);
    }

1. toString():转成字符串

public String toString() {
    return String.valueOf(value);
    }

4.各种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;
    }

5.hashCode():返回HashCode值(这个和整数的包装类就不一样的。整数的HashCode都是它本身的值)

 public int hashCode() {
    return floatToIntBits(value);
    }

6.equals(Object obj)：判断value的值属否相等

 public boolean equals(Object obj) {
    return (obj instanceof Float)
           && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
    }

1. compareTo(Float anotherFloat):比较value的值的大小(实质是调用compare(float f1, float f2)这个静态方法)

  public int compareTo(Float anotherFloat) {
        return Float.compare(value, anotherFloat.value);
    }