1. 简介

Double类封装了一个值double原始类型的对象。此外，这个类提供了一些方法来转换double，String，以及其他处理double的常量和方法。
浮点类型的计算机表示形式与整数不同，建议先了解IEEE 754 浮点类型表示

2. 源码

---

(1) 实例变量：

同其他Number实现类，只有一个value
1.value：表示数值

    private final double value;

(2) 实例方法：

1.*value：byteValue、shortValue、intValue、longValue、floatValue、doubleValue

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

2.toString()：调用FloatingDecimal返回double数值字符串，十进制形式

    public static String toString(double d) {
        return FloatingDecimal.toJavaFormatString(d);
    }

3.equals(Object)：
调用doubleToLongBits转换为long类型进行比较

    public boolean equals(Object obj) {
        return (obj instanceof Double)
               //doubleToLongBits详解见下
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

4.compareTo(Double)：比较大小，-1,0,1
调用类方法compare，详解见下

    public int compareTo(Double anotherDouble) {
        return Double.compare(value, anotherDouble.value);
    }

4.NaN：判断是不是一个数字

NaN（Not a Number，非数）是计算机科学中数值数据类型的一类值，表示未定义或不可表示的值。常在浮点数运算中使用。首次引入NaN的是1985年的IEEE 754浮点数标准。

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

(3) 类变量：

1.MAX_VALUE：最大值
详见 IEEE 754 浮点类型表示

    // 1.7976931348623157e+308
    public static final double MAX_VALUE = 0x1.fffffffffffffP+1023;

2.MIN_NORMAL：最小正数
详见 IEEE 754 浮点类型表示

    // 2.2250738585072014E-308
    public static final double MIN_NORMAL = 0x1.0p-1022;

3.MIN_VALUE：最小值
详见 IEEE 754 浮点类型表示

    // 4.9e-324
    public static final double MIN_VALUE = 0x0.0000000000001P-1022; 

4.MAX_EXPONENT：最大指数，中的x指数
详见 IEEE 754 浮点类型表示

    public static final int MAX_EXPONENT = 1023;

5.MIN_EXPONENT：最小指数，中的x指数
详见 IEEE 754 浮点类型表示

    public static final int MIN_EXPONENT = -1022;

6.POSITIVE_INFINITY：正无穷

    public static final double POSITIVE_INFINITY = 1.0 / 0.0;

7.NEGATIVE_INFINITY：负无穷

    public static final double NEGATIVE_INFINITY = -1.0 / 0.0;

(4) 类方法：

1.isNaN(double)：判断是否是一个数字

NaN是唯一与自己不相等的值，NaN与任何值都不相等

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

2.isInfinite(double)：判断是否无穷大

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

3.isFinite(double)：判断是否有穷大

    public static boolean isFinite(double d) {
        return Math.abs(d) <= DoubleConsts.MAX_VALUE;
    }

4.doubleToRawLongBits：原始方法，将double的二进制按整数类型来计算值，并返回long类型值。

    public static native long doubleToRawLongBits(double value);

5.doubleToLongBits(double)：double类型占64位，跟long一样，这里是将double的64位表示原封不动的按整数类型来表示，正好跟long对应，所以说，一个double跟一个long对应，一个float跟一个int对应。
转换有很多好处，比较大小，可以通过对应的整数类型来比较。

    public static long doubleToLongBits(double value) {
        long result = doubleToRawLongBits(value);
        // Check for NaN based on values of bit fields, maximum
        // exponent and nonzero significand.
        if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
              DoubleConsts.EXP_BIT_MASK) &&
             (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
            result = 0x7ff8000000000000L;
        return result;
    }

6.hashCode(double)：哈希值，与Long处理方式一致

    public static int hashCode(double value) {
        long bits = doubleToLongBits(value);
        return (int)(bits ^ (bits >>> 32));
    }

7.compare(double, double)：比较两个double值，-1,0,1
先按二进制转为long值，然后计算大小，对应的long值和double相对大小还是一样，因为

• 最高位是符号位，一样
• 第二部分是指数位，指数越大，数值绝对值越大，对应的double也就越大，相比第三部分尾数来说，指数位影响力远远大于尾数
• 符号位和指数位都相同时，才比较尾数位，和整数比较基本一致

    public static int compare(double d1, double d2) {
        if (d1 < d2)
            return -1;           // Neither val is NaN, thisVal is smaller
        if (d1 > d2)
            return 1;            // Neither val is NaN, thisVal is larger

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

8.longBitsToDouble：将long类型的二进制按double类型来计算

    public static native double longBitsToDouble(long bits);

9.其他方法：都是常规的方法了

    public static Double valueOf(String s) throws NumberFormatException {
        return new Double(parseDouble(s));
    }
    public static Double valueOf(double d) {
        return new Double(d);
    }
    public static double parseDouble(String s) throws NumberFormatException {
        return FloatingDecimal.parseDouble(s);
    }
    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);
    }

(5) 构造器：

1.Double(double)：按值构造

    public Double(double value) {
        this.value = value;
    }

2.Double(String)：按字符构造

    public Double(String s) throws NumberFormatException {
        value = parseDouble(s);
    }

后言

---

相比较整数类型，因为数值分布的不确定性，浮点类型没有缓存池机制。

其他

---

本人也是在慢慢学习中，如有错误还请原谅、敬请指出，谢谢！