Double源码

这个类自定义的字段稍微有点多，看的时候需要注意一下这些字段的含义

进制转换的时候需要特别注意进制的转换方法, 应该如何的去计算，以及验证。

这个类里面用到了sun包里面的一些方法，对于JDK自带的源码中是不包含sun包的源码的。我去这位博主https://blog.youkuaiyun.com/qq_27605885/article/details/81782916的博客下面复制过来了如下：

jdk目录下是有源码的，但是源码不包含sun包，

但是openjdk网站有提供的：http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/6bfaecb8ff77/src/share/classes/

或者直接用百度网盘下载：https://pan.baidu.com/s/1JaX50ETPaneQ-xFut3G--g

我的源码分析如下：

package java.lang;

import sun.misc.FloatingDecimal;
import sun.misc.FpUtils;
import sun.misc.DoubleConsts;

public final class Double extends Number implements Comparable<Double> {
    // double类型的正无穷大的常量。 它等于0x7ff0000000000000L
    public static final double POSITIVE_INFINITY = 1.0 / 0.0;
    // double类型的负无穷大的常量。 它等于0xfff0000000000000L
    public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
    // double类型的Not-a-Number（NaN）值的常量。 等于0x7ff8000000000000L
    public static final double NaN = 0.0d / 0.0;
    // double类型的最大正有限值 1.7976931348623157e+308
    public static final double MAX_VALUE = 0x1.fffffffffffffP+1023;
    // double类型最小正正常值的常量 2.2250738585072014E-308
    public static final double MIN_NORMAL = 0x1.0p-1022;
    // double类型的最小正非零值的常量 4.9e-324
    public static final double MIN_VALUE = 0x0.0000000000001P-1022;
    // double 变量的最大指数。
    public static final int MAX_EXPONENT = 1023;
    // double 变量的最小指数。
    public static final int MIN_EXPONENT = -1022;
    // double 变量最大的长度
    public static final int SIZE = 64;
    // 表示double值的字节数
    public static final int BYTES = SIZE / Byte.SIZE;
    // double的原始类型
    @SuppressWarnings("unchecked")
    public static final Class<Double>   TYPE = (Class<Double>) Class.getPrimitiveClass("double");
    
    // 将double数据转换成字符串
    // 需要用至sun包
    public static String toString(double d) {
        return FloatingDecimal.toJavaFormatString(d);
    }
    
    // 将10进制的double转换成16进制的字符串
    // 例： 567.9D  -->  0x1.1bf3333333333p9
    // --> {1*16^0 + 1*16^(-1)+b*16^(-2)+f*16^(-3)+3*16^(-4)+...}*2^9
    public static String toHexString(double d) {
        // d的绝对修值大于MAX_VALUE
        if (!isFinite(d) )
            // 对于无穷大和NaN，请使用小数输出。.
            return Double.toString(d);
        else {
            // 初始化为最大输出大小。
            StringBuilder answer = new StringBuilder(24);
            // d为负，将"-"添加在首位
            if (Math.copySign(1.0, d) == -1.0)    // value is negative,
                answer.append("-");                  // so append sign info
            // 添加16进制的标志
            answer.append("0x");
            // 求绝对值
            d = Math.abs(d);
            // d是否为0
            if(d == 0.0) {
                answer.append("0.0p0");
            } else {
                // 判断是以1开头还是以0开头
                boolean subnormal = (d < DoubleConsts.MIN_NORMAL);
                long signifBits = (Double.doubleToLongBits(d)
                                   & DoubleConsts.SIGNIF_BIT_MASK) |
                    0x1000000000000000L;
                answer.append(subnormal ? "0." : "1.");
                // 获取小数位的16进制
                String signif = Long.toHexString(signifBits).substring(3,16);
                answer.append(signif.equals("0000000000000") ? // 13 zeros
                              "0":
                              signif.replaceFirst("0{1,12}$", ""));
                answer.append('p');
                // 计算是2的多少次方
                answer.append(subnormal ?
                              DoubleConsts.MIN_EXPONENT:
                              Math.getExponent(d));
            }
            return answer.toString();
        }
    }
    
    // 传入double类型的字符串，返回doubli小数
    public static Double valueOf(String s) throws NumberFormatException {
        return new Double(parseDouble(s));
    }
    
    // 获取Double包装类型的小数
    public static Double valueOf(double d) {
        return new Double(d);
    }
    // 将double字符串转换成,double类型的小数
    public static double parseDouble(String s) throws NumberFormatException {
        return FloatingDecimal.parseDouble(s);
    }
    
    // nan表示0/0正负无穷大，没有任何数与nan相等，故此处总是false
    public static boolean isNaN(double v) {
        return (v != v);
    }
    
    // v是正无穷大或者是负无穷大时为true, 否则是false
    public static boolean isInfinite(double v) {
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
    }
    
    // 是否是有限的
    public static boolean isFinite(double d) {
        // 其绝对值比定义的最大值要小，那么就是有限的
        return Math.abs(d) <= DoubleConsts.MAX_VALUE;
    }
    // 定义一个变量用来接收double
    private final double value;
    // 构造函数，传入一个double
    public Double(double value) {
        this.value = value;
    }
    // 构造函数，传入一个字符串
    public Double(String s) throws NumberFormatException {
        // 先将字符串转换成double,
        value = parseDouble(s);
    }
    
    // 0不能作为被除数，这里永远为false
    public boolean isNaN() {
        return isNaN(value);
    }
    // 是否是有限的
    public boolean isInfinite() {
        return isInfinite(value);
    }

    // 将double类型的数据转换成其它类型的数据
    public String toString() {
        return 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 (float)value;
    }
    public double doubleValue() {
        return value;
    }
    
    // 获取double数据的hashCode
    @Override
    public int hashCode() {
        return Double.hashCode(value);
    }
    // 计算double数据的hashCode
    public static int hashCode(double value) {
        long bits = doubleToLongBits(value);
        return (int)(bits ^ (bits >>> 32));
    }
    
    // 比较两个double数据
    public boolean equals(Object obj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }
    
    // 将double数据转换为long类型的字节
    public static long doubleToLongBits(double value) {
        long result = doubleToRawLongBits(value);
        //根据位字段，最大指数和非零有效数的值检查NaN。
        if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
              DoubleConsts.EXP_BIT_MASK) &&
             (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
            result = 0x7ff8000000000000L;
        return result;
    }
    
    // 
    public static native long doubleToRawLongBits(double value);
    public static native double longBitsToDouble(long bits);
    // 比较两个double数据
    public int compareTo(Double anotherDouble) {
        return Double.compare(value, anotherDouble.value);
    }
    
    // 比较两个double数据,返回-1，0，1
    public static int compare(double d1, double d2) {
        if (d1 < d2)
            return -1;
        if (d1 > d2)
            return 1;
        // 由于NaNs的可能性，不能使用doubleToRawLongBits.
        long thisBits    = Double.doubleToLongBits(d1);
        long anotherBits = Double.doubleToLongBits(d2);

        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 double sum(double a, double b) {
        return a + b;
    }
    // 求大值
    public static double max(double a, double b) {
        return Math.max(a, b);
    }
    // 求小值
    public static double min(double a, double b) {
        return Math.min(a, b);
    }
    private static final long serialVersionUID = -9172774392245257468L;
}