JDK1.8源码学习--lang包(Float)

前言

月是一轮明镜,晶莹剔透,代表着一张白纸(啥也不懂)

央是一片海洋,海乃百川,代表着一块海绵(吸纳万物)

泽是一柄利剑,千锤百炼,代表着千百锤炼(输入输出)

月央泽,学习的一种过程,从白纸->吸收各种知识->不断输入输出变成自己的内容

希望大家一起坚持这个过程,也同样希望大家最终都能从零到零,把知识从薄变厚,再由厚变薄!
 

一.Float的作用:

        直接看源码注释(我的翻译可能不太准,如果道友们有更棒的理解,可以留言或者私信)

/**
 * The {@code Float} class wraps a value of primitive type
 * {@code float} in an object. An object of type
 * {@code Float} contains a single field whose type is
 * {@code float}.
 * 1.Float类将原始类型 float的值包装在一个对象中。Float类型的对象包含一个类型为float的字段
 * <p>In addition, this class provides several methods for converting a
 * {@code float} to a {@code String} and a
 * {@code String} to a {@code float}, as well as other
 * constants and methods useful when dealing with a
 * {@code float}.
 * 2.此外，该类提供了几种将float转换为String和将 String转换为 float的方法，以及在处理{float}
 * @author  Lee Boynton
 * @author  Arthur van Hoff
 * @author  Joseph D. Darcy
 * @since JDK1.0
 */

二.Character的类图:

 

    a).一个Comparable,这个接口对实现他的每个对象都可按照一定的规则来进行排序,详情请点击下面链接

        JDK1.8源码学习--lang包(Comparable)_w5_Silence的博客-CSDN博客

    b).Secializable,这个接口是可为实现的对象进行序列化,详情请点击下面链接
                  ......(假装这个是链接,以后补充)

    c).Numer,这个抽象类对一些数字操作进行了相关规范

       JDK1.8源码学习--lang包(Number)_w5_Silence的博客-CSDN博客

   三.成员变量: 

    /**
     * 保持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类型的非数字 (NaN) 值的常量。相当于Float.intBitsToFloat(0x7fc00000)返回的值
     */
    public static final float NaN = 0.0f / 0.0f;

    /**
     * 一个常量，持有float类型的最大正有限值。它等于十六进制浮点文字 0x1.fffffeP+127f
     * 也等于  Float.intBitsToFloat(0x7f7fffff)
     */
    public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f

    /**
     *一个常量，持有float类型的最小正正常值.它等于十六进制浮点文字 0x1.0p-126f
     * 也等于Float.intBitsToFloat(0x00800000)
     */
    public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f

    /**
     * 一个常量，包含 float类型的最小正非零值。它等于十六进制浮点文字0x0.000002P-126f
     * 也等于 Float.intBitsToFloat(0x1)
     */
    public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f

    /**
     * 有限 float变量可能具有的最大指数。它等于 Math.getExponent(Float.MAX_VALUE)返回的值
     */
    public static final int MAX_EXPONENT = 127;

    /**
     * 标准化 float变量可能具有的最小指数。它等于 Math.getExponent(Float.MIN_NORMAL)返回的值
     */
    public static final int MIN_EXPONENT = -126;

    /**
     * 用于表示 float值的位数
     */
    public static final int SIZE = 32;

    /**
     * 用于表示 float值的字节数
     */
    public static final int BYTES = SIZE / Byte.SIZE;

    /**.
     * 表示原始类型float的  Class 实例
     */
    @SuppressWarnings("unchecked")
    public static final Class<Float> TYPE = (Class<Float>) Class.getPrimitiveClass("float");

  /**
     * The value of the Float.
     *浮点数的值
     * @serial
     */
    private final float value;

四.构造方法: 

   /**
     * 构造一个新分配的Float对象，表示原始float参数
     */
    public Float(float value) {
        this.value = value;
    }

    /**
     * 构造一个新分配的Float 对象，该对象表示转换为 float类型的参数
     */
    public Float(double value) {
        this.value = (float)value;
    }

    /**
     * 构造一个新分配的Float对象，该对象表示由字符串表示的float类型的浮点值。
     * 字符串被转换为 float值，就像通过 valueOf方法一样。
     */
    public Float(String s) throws NumberFormatException {
        value = parseFloat(s);
    }

五.内部方法:  

                toString

    /**
     *     1.返回 float参数的字符串表示形式
     *     2.下面提到的所有字符都是ASCII字符:
     *      1)如果参数是 NaN，则结果是字符串 "NaN"
     *      2)否则，结果是一个字符串，表示参数的符号和大小（绝对值）。
     *      如果符号为负，则结果的第一个字符为'-'；如果符号为正，则结果中不出现符号字符。
     *      
     *     3.至于幅度m:

     *     如果m为无穷大，则用字符"Infinity"表示；因此，正无穷产生结果"Infinity"，负无穷产生结果"-Infinity"

     *     如果m为零，则用字符"0.0"表示；因此，负零产生结果"-0.0"，正零产生结果"0.0"

     *      如果m大于等于10的-3次方,但小于10的7次方，则表示为m的整数部分，十进制形式，
     *      没有前导零，后跟'.'，后跟一个或多个十进制数字，代表m的小数部分

     *  如果m小于10<sup>-3<sup>或大于或等于10<sup>7<sup>，则用所谓的“计算机科学记数法”表示。
     *  令n为唯一整数，使得 10<sup>n <sup>≤ m <10<sup>n+1<sup>;
     *  然后让 a成为m和 10<sup>n<sup> 的数学上精确商，使得 1 ≤ a <10. 
     *  然后将幅度表示为 a的整数部分，作为单个十进制数字，后跟 '.'，
     *  然后是由代表a 小数部分的十进制数字，后跟字母 'E' ，接着是n的表示作为十进制整数，由方法java.lang.IntegertoString(int)产生

     * m或 a的小数部分必须打印多少位数字？必须至少有一个数字来表示小数部分，
     * 并且超过这个数字，但只能是唯一地将参数值与float类型的相邻值区分开来所需的数字。
     * 也就是说，假设 x是由此方法为有限非零参数 f 生成的十进制表示所表示的精确数学值。
     * 那么f必须是最接近x的float值；或者，如果两个float值同样接近 x，
     * 则 f必须是其中之一，并且是 f的有效数的最低有效位必须是0

     * 要创建浮点值的本地化字符串表示，请使用  java.text.NumberFormat的子类

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

    /**
      返回 {@code 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
            //float subnormal 调整指数以创建 subnormal double，然后用 subnormal float 指数替换 subnormal double 指数
            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);
    }

/**
     * 返回此Float对象的字符串表示形式。由该对象表示的原始float值被完全转换为 String，
     * 就像通过一个参数的方法 toString 一样。
     */
    public String toString() {
        return Float.toString(value);
    }

                valueOf

 /**
     * 1.返回一个 Float对象，其中包含由参数字符串s表示的 float值
     *2.如果 s为 null，则抛出NullPointerException
     * 3.s中的前导和尾随空白字符将被忽略。像Stringtrim方法一样删除空格；也就是说，ASCII 空格和控制字符都被删除了,
     *  s 的其余部分应构成一个FloatValue ，如词法语法规则所述
    
     * 4.其中Sign、FloatingPointLiteral、HexNumeral、HexDigits、SignedInteger 
     * 和 FloatTypeSuffix为在<Java™ 语言规范<的词法结构部分中定义，除了数字之间不接受下划线。

     * 5.如果s不具有 FloatValue的形式，则抛出NumberFormatException。
     * 否则， s被视为表示通常的“计算机化科学记数法”中的精确十进制值或精确的十六进制值；
     * 然后，这个精确的数值在概念上被转换为一个“无限精确”的二进制值，
     * 然后通过 IEEE 754 浮点运算的通常舍入到最近的规则舍入到类型 float，其中包括保留一个零值
 
     * 6.请注意，舍入到最近的规则还暗示上溢和下溢行为；如果 s
     * 的准确值在数量级上足够大（大于或等于 MAX_VALUE +Math.ulp(float) ），
     * 四舍五入到float将导致无穷大，如果s的确切值在数量上足够小（小于或等于MIN_VALUE），
     * 四舍五入到浮点数将导致零。

     * 7.最后，在舍入表示此float值的Float对象后返回
.
     * 8.要解释浮点值的本地化字符串表示，请使用java.text.NumberFormat的子类
  
     * 9.请注意尾随格式说明符，确定浮点文字类型的说明符1.0f是一个float值；
     * {1.0d} 是一个  double值），请执行不影响这个方法的结果。换句话说，
     * 输入字符串的数值直接转换为目标浮点类型。一般来说，字符串到 double
     * 后跟 double到float的两步转换序列不相当于将字符串直接转换为 {Double}。
     * 例如，如果首先转换为中间double，然后转换为 float，
     * 则字符串"1.00000017881393421514957253748434595763683319091796875001d"值 
     * 导致浮点数代码 1.0000002f;如果字符串直接转换为 float，则结果为1.0000001f
 
     * 10.为了避免在无效字符串上调用此方法并抛出NumberFormatException，

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

    /**
     * 1.返回一个 Float实例，表示指定的 float值。
     * 2.如果不需要新的 Float实例，则通常应优先使用此方法而不是构造函数Float(float)，
     * 因为此方法可能会通过缓存频繁请求的内容来显着提高空间和时间性能价值观

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

                parseFloat

 /**

     * 返回一个新的 float，初始化为由指定的String表示的值，由 Float类的 valueOf方法执行
     */
    public static float parseFloat(String s) throws NumberFormatException {
        return FloatingDecimal.parseFloat(s);
    }

                判断类

  /**
     * 如果此Float 值是非数字 (NaN)，则返回true，否则返回false
     */
    public boolean isNaN() {
        return isNaN(value);
    }

    /**
     * 如果此 Float值的大小无限大，则返回 true，否则返回false。
     */
    public boolean isInfinite() {
        return isInfinite(value);
    }

 /**
     * 如果指定的数字是非数字 (NaN)值，则返回 true，否则返回 false
     */
    public static boolean isNaN(float v) {
        return (v != v);
    }

    /**
     * 如果指定数字的大小无限大，则返回true，否则返回false。
     */
    public static boolean isInfinite(float v) {
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
    }


    /**.
     * 如果参数是有限浮点值，则返回 true；否则返回 false,对于 NaN 和无穷大参数）
     */
     public static boolean isFinite(float f) {
        return Math.abs(f) <= FloatConsts.MAX_VALUE;
    }

                与其他数字类型的原始类型转换

    /**
     * 在缩小原始转换后，将此 Float的值作为 byte返回
     */
    public byte byteValue() {
        return (byte)value;
    }

    /**
     * 在缩小原始转换后，将此Float的值作为short返回
     */
    public short shortValue() {
        return (short)value;
    }

    /**
     * 在缩小原始转换后，将此Float的值作为int返回。
     */
    public int intValue() {
        return (int)value;
    }

    /**
     * 在缩小原始转换后，将此 Float的值作为 long返回。
     */
    public long longValue() {
        return (long)value;
    }

    /**
     * 返回此 Float对象的 float值
     */
    public float floatValue() {
        return value;
    }

    /**
     * 在扩展原始转换后，将此 Float的值作为 double返回。
     */
    public double doubleValue() {
        return (double)value;
    }

                hashCode

  /**
     * 返回此 Float对象的哈希码。结果是该 Float对象表示的原始float值的整数位表示，
     * 与方法 floatToIntBits(float)完全相同。
     */
    @Override
    public int hashCode() {
        return Float.hashCode(value);
    }

    /**
     * 返回float 值的哈希码；与 Float.hashCode()兼容
     */
    public static int hashCode(float value) {
        return floatToIntBits(value);
    }

                equals

    /**

     * 1.将此对象与指定的对象进行比较。结果是 true当且仅当参数不是 null并且是一个 Float对象，
     * 该对象表示与 float具有相同值的 float通过这个对象。为此，当且仅当方法floatToIntBits(float)
     * 在应用于每个时返回相同的int值时，两个  float值被认为是相同的

     *2.注意，在大多数情况下，对于 f1和 f2类的两个实例，f1.equals(f2)的值是true
 
     *     3.但是，有两个例外

     *     如果 f1和 f2都表示 Float.NaN，那么equals方法返回true，
     *     即使 Float.NaN==Float.NaN的值为 false。
 
     *     如果f1代表+0.0f而f2代表-0.0f，反之亦然，equal测试的值为 false，
     *     即使尽管 0.0f==-0.0f的值为 true

     * This definition allows hash tables to operate properly.
     * 此定义允许哈希表正常运行

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

                floatToIntBit

  /**
     * 1.根据 IEEE 754 浮点“单一格式”位布局返回指定浮点值的表示形式

     * 2.第 31 位（掩码 0x80000000选择的位）表示浮点数的符号
 
     * 3.位 30-23（由掩码 0x7f800000选择的位）代表指数。

     * 4.位 22-0（由掩码 0x007fffff选择的位）表示浮点数的有效数（有时称为尾数）

     * 5.如果参数为正无穷大，则结果为0x7f800000。

     * 6.如果参数为负无穷大，则结果为 0xff800000

     * 7.如果参数为 NaN，则结果为 0x7fc00000

     * 8.在所有情况下，结果都是一个整数，当给 intBitsToFloat(int)方法时，
     * 将产生一个与floatToIntBits的参数相同的浮点值（除了所有 NaN 值被折叠到单个“规范”NaN 值）

     */
    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;
    }

                compare

/**
     * 1.以数字方式比较两个Float对象。此方法执行的比较与 Java 语言数值比较运算符 ( <, <=, ==, >=, >) 
     * 执行的比较有两种不同之处
     * 2.当应用于原始float 值时:
     *   此方法认为Float.NaN等于自身并大于所有其他float值（包括 Float.POSITIVE_INFINITY
     *   此方法认为 0.0f大于 -0.0f

     * 3.这确保了此方法强加的Float对象的 自然顺序与 equals一致
     */
    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.
        //由于可能存在 NaN，因此无法使用 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)
    }

                计算类

   /**
     * 根据 + 运算符将两个 {@code float} 值相加。
     */
    public static float sum(float a, float b) {
        return a + b;
    }

    /**

     * 返回两个 float值中的较大者，就像通过调用  Math.max(float, float) Math.max一样
     */
    public static float max(float a, float b) {
        return Math.max(a, b);
    }

    /**
     * 返回两个float值中较小的一个，就像调用 Math.min(float, float) Math.min
     */
    public static float min(float a, float b) {
        return Math.min(a, b);
    }

七.总结: 

        和Double巨类似,看这类应该不会很困难了....