JDK源碼-Double類

上節我們介紹過JDK源碼-Byte類
本節我們介紹Double類，float 單精度浮點數在內存內佔 4 個字節，用 32 位二進制描述，double 雙精度浮點數在內存內佔 8 個字節，用 64 位二進制描述。

---

一、實現接口

Double類是基本類型double的包裝類，繼承了Number類，並且實現了Comparable接口

public final class Double extends Number implements Comparable<Double> 

---

二、構造方法

	//構造一個新分配的 Double 對象，它表示轉換爲 double 類型的參數。
  	public Double(double value) {
        this.value = value;
    }
    //構造一個新分配的 Double 對象，它表示 String 參數所指示的 double 值。
    public Double(String s) throws NumberFormatException {
        value = parseDouble(s);
    }

用來存放Double對象那double對應的值。

 private final double value;

如下創建Double 對象:
Double double1=new Double(5.456); //以 double 類型的變量作爲參數創建 Double 對象
Double double2=new Double(“5.456”); //以 String 類型的變量作爲參數創建 Double 對象

---

三、常用常量

這些常量都是static靜態的，可直接使用 “類名.常量名” 進行使用

	//保持 double 類型的正無窮大的常量。
 	public static final double POSITIVE_INFINITY = 1.0 / 0.0;
 	//保持 double 類型的負無窮大的常量。
    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; // 1.7976931348623157e+308
    //標準化的最小值
    public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308
    //表示 double 類型數據能夠保持的最小正非零值的常量。
    public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324
    //指數真值的有效的最大值
    public static final int MAX_EXPONENT = 1023;
    //指數真值的有效的最小值
    public static final int MIN_EXPONENT = -1022;
    //用秦以二進制補碼形式表示 double 值的比特位數
    public static final int SIZE = 64;
    //二進制補碼形式表示 double 值的字節數
    public static final int BYTES = SIZE / Byte.SIZE;
	//表示基本類型 double 的 Class 實例。
    @SuppressWarnings("unchecked")
    public static final Class<Double>   TYPE = (Class<Double>) Class.getPrimitiveClass("double");

---

四、常用方法

toXXXString 系列

	//靜態方法
 	public static String toString(double d) {
        return FloatingDecimal.toJavaFormatString(d);
    }
    
    //實例方法內部調用  static String toString(double d)
	public String toString() {
        return toString(value);
    }
    
    //靜態方法返回double參數的十六進制字符串表示形式API幫助文檔中對於字符的轉換有明確的規定,可以仔細研究下示例
    public static String toHexString(double d) {
        if (!isFinite(d) )
            // For infinity and NaN, use the decimal output.
            return Double.toString(d);
        else {
            // Initialized to maximum size of output.
            StringBuilder answer = new StringBuilder(24);

            if (Math.copySign(1.0, d) == -1.0)    // value is negative,
                answer.append("-");                  // so append sign info

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

---

valueOf(String s)

傳入String類型字符串，通過parseDouble方法將字符串解析爲double，創建一個Double對象返回，保存指定的 String 值的 Double 對象。

 	public static Double valueOf(String s) throws NumberFormatException {
        return new Double(parseDouble(s));
    }

    public static Double valueOf(double d) {
        return new Double(d);
    }

---

parseDouble(String s)

將數字字符串轉換爲 Double 數值

 	public static double parseDouble(String s) throws NumberFormatException {
        return FloatingDecimal.parseDouble(s);
    }

---

isNaN(double v)

	//如果指定的參數是一個非數字值，則返回 true，否則返回 false
	public static boolean isNaN(double v) {
        return (v != v);
    }
    //如果此 Double 值是一個非數字值，則返回 true，否則返回 false
    public boolean isNaN() {
        return isNaN(value);
    }

---

isInfinite和isFinite

	//判斷double值的大小是否是無窮大，如果是則返回true；否則返回false。
 	public static boolean isInfinite(double v) {
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
    }
	//判斷是否是有限的浮點數，有限的true
    public static boolean isFinite(double d) {
        return Math.abs(d) <= DoubleConsts.MAX_VALUE;
    }

---

XXXValue系列

類似之前介紹的其他數值類型全部都是強轉內部的 valuereturn (XXX)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;
    }

---

equals(Object obj)

將此對象與指定對象比較當且僅當參數不是 null 而是 Double 對象，且表示的 Double 值與此對象表示的 double 值相同時，結果爲 true

注意，在大多數情況下，對於 Double 類的兩個實例 d1 和 d2，當且僅當d1.doubleValue() == d2.doubleValue() 爲 true 時，d1.equals(d2) 的值才爲 true
例外情況：
如果 d1 和 d2 都表示 Double.NaN，那麼即使 Double.NaN == Double.NaN 值爲 false，equals 方法也將返回 true
如果 d1 表示 +0.0 而 d2 表示 -0.0，或者相反，那麼即使 +0.0==-0.0 值爲 true，equals 測試也將返回 false

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

---

hashCode方法

	//實例方法依賴靜態方法
 	@Override
    public int hashCode() {
        return Double.hashCode(value);
    }

	//靜態方法獲得一個value的hashcode值
    public static int hashCode(double value) {
        long bits = doubleToLongBits(value);
        return (int)(bits ^ (bits >>> 32));
    }

---

其他方法

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

---

五、總結

double會出現精度丟失問題：整數永遠可以用二進制精確表示 ，但小數就不一定了
解決方案：
java中提供了一種類：BigDecimal，在平常的開發中使用java.math.BigDecimal類來進行精確計算。
在使用BigDecimal類來進行計算的時候，主要分爲以下步驟：

• 用float或者double變量構建BigDecimal對象。
• 通過調用BigDecimal的加，減，乘，除等相應的方法進行算術運算。
• 把BigDecimal對象轉換成float，double，int等類型。

一般來說，可以使用BigDecimal的構造方法或者靜態方法的valueOf()方法把基本類型的變量構建成BigDecimal對象。

	BigDecimal b1 = new BigDecimal(Double.toString(0.48)); 
 	BigDecimal b2 = BigDecimal.valueOf(0.48);