java.lang.*中Double 源代码详解

- 日理万妓 2022-12-01 15:56 248阅读 0赞

### java.lang.\*中Double 源代码详解 ###

*   *  核心方法
     *  String toString(double d)
     *  String toHexString(double d)
     *  Double valueOf(String s)
     *  Double valueOf(String s)
     *  double parseDouble(String s)
     *  boolean isNaN(double v)
     *  boolean isInfinite(double v)
     *  boolean isFinite(double d)
     *  public Double()
     *  byte byteValue()
     *  short shortValue()
     *  int intValue()
     *  long longValue()
     *  float floatValue()
     *  double doubleValue()
     *  int hashCode()
     *  boolean equals(Object obj)
     *  int compareTo(Double anotherDouble)
     *  double sum(double a, double b)
     *  double max(double a, double b)
     *  double min(double a, double b)

## 核心方法 ##

public final class Double extends Number implements Comparable<Double>
    
    String toString(double d) 返回double数字的字符串形式[OK]
    String toHexString(double d) 获取double数字的16进制表示形式[OK]
    Double valueOf(String s) 将字符串转换为Double类型对象[OK]
    Double valueOf(double d) 将double类型的数值,转换为Double类型对象[OK]
    double parseDouble(String s) 将字符串转换为double数值[OK]
    boolean isNaN(double v) 判断v是否为非数字[OK]
    boolean isInfinite(double v) 判断数值是否无穷大[OK]
    boolean isFinite(double d) 判断数值是否在有限范围内[OK]
    public Double() 构造函数[OK]
    byte byteValue() 获取Double类型对象的整数部分(会丢失小数点后的数据)[OK]
    short shortValue() 获取Double类型对象的short类型数据(会丢失小数点后的数据)[OK]
    int intValue() 获取Double类型对象的int类型数据(会丢失小数点后的数据)[OK]
    long longValue() 获取Double类型对象的long类型数据(会丢失小数点后的数据)[OK]
    float floatValue() 获取Double类型对象的float类型数据(只会保留小数点后6位数字)[OK]
    double doubleValue() 获取Double类型对象的double类型数据[OK]
    int hashCode() 获取Double对象的HashCode值[OK]
    boolean equals(Object obj) 比较两个hashCode,判断两个对象是否相等[OK]
    native long doubleToRawLongBits(double value) 将double类型数据转为long类型数据(和longBitsToDouble对称)[OK]
    native double longBitsToDouble(long bits) 将long类型数据转为double类型数据[OK]
    int compareTo(Double anotherDouble) 比较两个对象是否相等,如果相等返回0,否则返回-1或者1[OK]
    double sum(double a, double b) 求和两个double数值[OK]
    double max(double a, double b) 求两个double数值中的最大值[OK]
    double min(double a, double b) 求两个double数值中的最小值[OK]

## String toString(double d) ##

public static String toString(double d) { 
    	//采用浮点数处理
        return FloatingDecimal.toJavaFormatString(d);
    }

## String toHexString(double d) ##

/** * 获取double数字的16进制表示形式 */
    public static String toHexString(double d) { 
        /* * Modeled after the "a" conversion specifier in C99, section * 7.19.6.1; however, the output of this method is more * tightly specified. */
        if (!isFinite(d) )//判断d是否大于DoubleConsts.MAX_VALUE
            // For infinity and NaN, use the decimal output.
            return Double.toString(d);
        else { 
            //初始化最大的输出长度为24
            StringBuilder answer = new StringBuilder(24);
    		//判断是否为负数
            if (Math.copySign(1.0, d) == -1.0)    // value is negative,
                answer.append("-");                  // so append sign info
    		//拼接Ox的16进制输出标志
            answer.append("0x");
    		//取double的绝对值
            d = Math.abs(d);
    
            if(d == 0.0) { //如果d=0.0,则拼接0.0p0
                answer.append("0.0p0");
            } else { 
                boolean subnormal = (d < DoubleConsts.MIN_NORMAL);
    
                // Isolate significand bits and OR in a high-order bit
                // so that the string representation has a known
                // length.
                long signifBits = (Double.doubleToLongBits(d)
                                   & DoubleConsts.SIGNIF_BIT_MASK) |
                    0x1000000000000000L;
    
                // Subnormal values have a 0 implicit bit; normal
                // values have a 1 implicit bit.
                answer.append(subnormal ? "0." : "1.");
    
                // Isolate the low-order 13 digits of the hex
                // representation. If all the digits are zero,
                // replace with a single 0; otherwise, remove all
                // trailing zeros.
                String signif = Long.toHexString(signifBits).substring(3,16);
                answer.append(signif.equals("0000000000000") ? // 13 zeros
                              "0":
                              signif.replaceFirst("0{1,12}$", ""));
    
                answer.append('p');
                // If the value is subnormal, use the E_min exponent
                // value for double; otherwise, extract and report d's
                // exponent (the representation of a subnormal uses
                // E_min -1).
                answer.append(subnormal ?
                              DoubleConsts.MIN_EXPONENT:
                              Math.getExponent(d));
            }
            return answer.toString();
        }
    }

## Double valueOf(String s) ##

/** * 将字符串转换为Double类型对象 */
    public static Double valueOf(String s) throws NumberFormatException { 
        return new Double(parseDouble(s));
    }

## Double valueOf(String s) ##

/** * 将double类型的数值,转换为Double类型对象 */
    public static Double valueOf(double d) { 
        return new Double(d);
    }

## double parseDouble(String s) ##

/** * 将字符串转换为double数值 */
    public static double parseDouble(String s) throws NumberFormatException { 
        return FloatingDecimal.parseDouble(s);
    }

## boolean isNaN(double v) ##

/** * 判断v是否为非数字 * 例如: * Double d = new Double(0.0/0.0); * Double f = new Double(20); * System.out.println(Double.isNaN(d)); * System.out.println(Double.isNaN(f)); *输出结果: * true * false */
    public static boolean isNaN(double v) { 
        return (v != v);
    }

## boolean isInfinite(double v) ##

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

## boolean isFinite(double d) ##

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

## public Double() ##

/** * 构造方法 */
    public Double(double value) { 
        this.value = value;
    }
    
    public Double(String s) throws NumberFormatException { 
        value = parseDouble(s);
    }

## byte byteValue() ##

/** * 获取Double类型对象的byte类型数据(会丢失小数点后的数据) */
    public byte byteValue() { 
        return (byte)value;
    }

## short shortValue() ##

/** * 获取Double类型对象的short类型数据(会丢失小数点后的数据) */
    public short shortValue() { 
        return (short)value;
    }

## int intValue() ##

/** * 获取Double类型对象的int类型数据(会丢失小数点后的数据) */
    public int intValue() { 
        return (int)value;
    }

## long longValue() ##

/** * 获取Double类型对象的long类型数据(会丢失小数点后的数据) */
    public long longValue() { 
        return (long)value;
    }

## float floatValue() ##

/** * 获取Double类型对象的float类型数据(只会保留小数点后6位数字) */
    public float floatValue() { 
        return (float)value;
    }

## double doubleValue() ##

/** * 获取Double类型对象的double类型数据 */
    public double doubleValue() { 
       return value;
    }

## int hashCode() ##

/** * 获取Double对象的hashCode值 */
    public int hashCode() { 
        return Double.hashCode(value);
    }
    
    public static int hashCode(double value) { 
    	//将double类型数据转为long类型
        long bits = doubleToLongBits(value);
        //1.将bits无符号右移32位
        //2.异或本身bits
        //3.将结果强转为int类型
        return (int)(bits ^ (bits >>> 32));
    }
    
    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;
    }
    
    //调用底层native内部方法,将double类型数据转为long类型
    public static native long doubleToRawLongBits(double value);

## boolean equals(Object obj) ##

/** * 比较两个hashCode,判断两个对象是否相等 */
    public boolean equals(Object obj) { 
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

## int compareTo(Double anotherDouble) ##

/** * 比较两个对象是否相等,如果相等返回0,否则返回-1或者1 */
    public int compareTo(Double anotherDouble) { 
        return Double.compare(value, anotherDouble.value);
    }
    
    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)
    }

## double sum(double a, double b) ##

public static double sum(double a, double b) { 
        return a + b;
    }

## double max(double a, double b) ##

public static double max(double a, double b) { 
        return Math.max(a, b);
    }
    
    public static double max(double a, double b) { 
        if (a != a)
            return a;   // a is NaN
        if ((a == 0.0d) &&
            (b == 0.0d) &&
            (Double.doubleToRawLongBits(a) == negativeZeroDoubleBits)) { 
            // Raw conversion ok since NaN can't map to -0.0.
            return b;
        }
        return (a >= b) ? a : b;
    }

## double min(double a, double b) ##

public static double min(double a, double b) { 
        return Math.min(a, b);
    }
    
    public static double min(double a, double b) { 
        if (a != a)
            return a;   // a is NaN
        if ((a == 0.0d) &&
            (b == 0.0d) &&
            (Double.doubleToRawLongBits(b) == negativeZeroDoubleBits)) { 
            // Raw conversion ok since NaN can't map to -0.0.
            return b;
        }
        return (a <= b) ? a : b;
    }

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！