JDK源码学习与分析之Double

        本文基于JDK1.8学习与分析Double源码。

public final class Double extends Number implements Comparable<Double>

        Double类包装一个对象中的原始类型double的值。 类型为Double的对象包含一个单一字段，其类型为double 。此外，该类还提供了几种将double转换为String和String转换为double ，以及在处理double时有用的其他常数和方法。

package java.lang;

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

/**
 * @author  Lee Boynton
 * @author  Arthur van Hoff
 * @author  Joseph D. Darcy
 * @since JDK1.0
 */
public final class Double extends Number implements Comparable<Double> {
    /**
     * double类型的正负无穷大
     */
    public static final double POSITIVE_INFINITY = 1.0 / 0.0;
    public static final double NEGATIVE_INFINITY = -1.0 / 0.0;

    /**
     * double类型的非数字值
     */
    public static final double NaN = 0.0d / 0.0;

    /**
     * double类型的最大正数值
     */
    public static final double MAX_VALUE = 0x1.fffffffffffffP+1023;

    /**
     * double类型的最小正数值
     */
    public static final double MIN_NORMAL = 0x1.0p-1022;

    /**
     * double最小的非零正值
     */
    public static final double MIN_VALUE = 0x0.0000000000001P-1022;

    /**
     * 最大指数常量1023
     */
    public static final int MAX_EXPONENT = 1023;

    /**
     * 最小指数常量-1022
     */
    public static final int MIN_EXPONENT = -1022;

    /**
     * 表示一个double值的位数
     */
    public static final int SIZE = 64;

    /**
     * 表示一个double值的字节数
     */
    public static final int BYTES = SIZE / Byte.SIZE;

    /**
     * 获取包装类对应的Class对象
     */
    @SuppressWarnings("unchecked")
    public static final Class<Double>   TYPE = (Class<Double>) Class.getPrimitiveClass("double");

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

    /**
     * 返回double参数的十六进制字符串double形式
     */
    public static String toHexString(double d) {
        if (!isFinite(d) )
            return Double.toString(d);
        else {
            StringBuilder answer = new StringBuilder(24);

            if (Math.copySign(1.0, d) == -1.0)
                answer.append("-");

            answer.append("0x");

            d = Math.abs(d);

            if(d == 0.0) {
                answer.append("0.0p0");
            } else {
                boolean subnormal = (d < DoubleConsts.MIN_NORMAL);
                long signifBits = (Double.doubleToLongBits(d)
                        & DoubleConsts.SIGNIF_BIT_MASK) |
                        0x1000000000000000L;
                answer.append(subnormal ? "0." : "1.");
                String signif = Long.toHexString(signifBits).substring(3,16);
                answer.append(signif.equals("0000000000000") ?
                        "0":
                        signif.replaceFirst("0{1,12}$", ""));

                answer.append('p');
                answer.append(subnormal ?
                        DoubleConsts.MIN_EXPONENT:
                        Math.getExponent(d));
            }
            return answer.toString();
        }
    }

    /**
     * 字符串解析成Double类型
     */
    public static Double valueOf(String s) throws NumberFormatException {
        return new Double(parseDouble(s));
    }

    /**
     * double返回Double包装类
     */
    public static Double valueOf(double d) {
        return new Double(d);
    }

    /**
     * 解析字符串为double
     */
    public static double parseDouble(String s) throws NumberFormatException {
        return FloatingDecimal.parseDouble(s);
    }

    /**
     * 判断double是否数值类型
     */
    public static boolean isNaN(double v) {
        return (v != v);
    }

    /**
     * 判断double是否无限大
     */
    public static boolean isInfinite(double v) {
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
    }

    /**
     * 判断double是否有限浮点数
     */
    public static boolean isFinite(double d) {
        return Math.abs(d) <= DoubleConsts.MAX_VALUE;
    }

    private final double value;

    /**
     * 有参构造方法
     */
    public Double(double value) {
        this.value = value;
    }

    /**
     * 参数为字符串的构造方法
     */
    public Double(String s) throws NumberFormatException {
        value = parseDouble(s);
    }

    /**
     * 判断是否数值类型
     */
    public boolean isNaN() {
        return isNaN(value);
    }

    /**
     * 判断是否无限大
     */
    public boolean isInfinite() {
        return isInfinite(value);
    }

    /**
     * Double转String
     */
    public String toString() {
        return toString(value);
    }

    /**
     * 获取double的byte类型值
     */
    public byte byteValue() {
        return (byte)value;
    }

    /**
     * 获取double的short类型值
     */
    public short shortValue() {
        return (short)value;
    }

    /**
     * 获取double的int类型值
     */
    public int intValue() {
        return (int)value;
    }

    /**
     * 获取double的long类型值
     */
    public long longValue() {
        return (long)value;
    }

    /**
     * 获取double的float类型值
     */
    public float floatValue() {
        return (float)value;
    }

    /**
     * 获取double的double类型值
     */
    public double doubleValue() {
        return value;
    }

    /**
     * double的哈希码
     */
    @Override
    public int hashCode() {
        return Double.hashCode(value);
    }

    /**
     * 获取给定double的哈希码
     */
    public static int hashCode(double value) {
        long bits = doubleToLongBits(value);
        return (int)(bits ^ (bits >>> 32));
    }

    /**
     * 将此对象与指定对象进行比较
     */
    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);
        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值
     */
    public static int compare(double d1, double d2) {
        if (d1 < d2)
            return -1;
        if (d1 > d2)
            return 1;
        long thisBits    = Double.doubleToLongBits(d1);
        long anotherBits = Double.doubleToLongBits(d2);

        return (thisBits == anotherBits ?  0 :
                (thisBits < anotherBits ? -1 :
                        1));
    }

    /**
     * 对两个double求和
     */
    public static double sum(double a, double b) {
        return a + b;
    }

    /**
     * 获取两个double中的较大值
     */
    public static double max(double a, double b) {
        return Math.max(a, b);
    }

    /**
     * 获取两个double中的较小值
     */
    public static double min(double a, double b) {
        return Math.min(a, b);
    }

    private static final long serialVersionUID = -9172774392245257468L;
}