JDK源码解析之 Java.lang.Float

栗筝i

发布于 2022-12-01 12:07:31

40100

代码可运行

文章被收录于专栏：迁移内容迁移内容

运行总次数：0

代码可运行

Float类是原始类型float的包装类，它包含若干有效处理浮点值的方法，如将其转换为字符串表示形式，反之亦然。Float类的一个对象可以包含一个浮点值

一、类定义

public final class Float extends Number implements Comparable<Float> {}

类被声明为final的,表示不能被继承;
继承了Number抽象类,可以用于数字类型的一系列转换;
实现了Comparable接口,强行对实现它的每个类的对象进行整体排序

二、成员变量

//一个保持正无穷大的 float 类型常数
public static final float POSITIVE_INFINITY = 1.0f / 0.0f;

//一个保持负无穷大的 float 类型常数  
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;

//值为NaN（Not a Number，非数）的一个 float 类型常数  
public static final float NaN = 0.0f / 0.0f;

//一个 float 类型常量存储 float 的有限最大值
 public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f

//一个 float 类型常量存储 float 的有限最小正数值
 public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f

//保持最小单精度类型的最小非零的常数
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;

//一个double类型变量为32位，即4个字节。
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");

三、构造器

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

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


    public Float(String s) throws NumberFormatException {
        value = parseFloat(s);
    }

Float 依然提供了根据基本类型float以及float的String形式构造，String形式依然借助于parseXXX形式 parseFloat

另外,也提供了根据基本类型double进行构造的方式,内部直接强转

四、常用方法

Float多数方法与Double方法类似

1、isNaN(float v)

静态方法，是否一个非数字 (NaN) 值，非数值 true

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

实例方法：boolean isNaN()

2、isFinite(float f)

静态方法，是否是有限的浮点数，有限的true

     public static boolean isFinite(float f) {
        return Math.abs(f) <= FloatConsts.MAX_VALUE;
    }

3、isInfinite(float v)

静态方法，是否是无穷大，是无穷大 true

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

实例方法：boolean isInfinite()

4、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

        // Cannot use floatToRawIntBits because of possibility of NaNs.
        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)
    }

f1 < f2 小于0，f1 = f2 等于0，f1 > f2 大于0

实例方法：int compareTo(Float anotherFloat)两个对象进行大小比较,依赖于静态方法

5、parseXXX系列

字符串解析为基本类型,

不需要对象,所以都是静态方法

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

6、valueOf系列

把基本基本类型包装为对象

用来创建获得对象,所以无需对象,全都是静态方法

    public static Float valueOf(String s) throws NumberFormatException {
        return new Float(parseFloat(s));
    }

7、XXXValue系列

byteValue()、shortValue()、intValue()、longValue()、floatValue()、doubleValue()

都是强转内部的 value

8、toString

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

9、equals(Object obj)

用于比较两个Float对象的相等性。如果两个对象都包含相同的float值，则此方法返回true。只有在检查平等的情况下才能使用。在其他所有情况下，compareTo方法应该是首选。

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

9、compareTo和compare

public int compareTo(Float anotherFloat) {
        return Float.compare(value, anotherFloat.value);
    }
 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

        // Cannot use floatToRawIntBits because of possibility of NaNs.
        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)
    }