一 概述
Double 类是基本类型double的包装类，fainl修饰，在对象中包装了一个基本类型double的值。Double继承了Number抽象类，具有了转化为基本double类型的功能。
此外，该类还提供了多个方法，可以将 double 类型与 String 类型相互转换，同时 还提供了处理 double 类型时比较常用的常量和方法。
二 Number类
三 源码解析
// 表示正无穷大， 注意：浮点数才有无穷的概念，整数是没有的 1/0 会直接报错
public static final double POSITIVE_INFINITY = 1.0 / 0.0;
// 负无穷
public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
// 表示非数 (即不是Number)
public static final double NaN = 0.0d / 0.0;
// 最大正有限值
public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308
//最小正标准值
public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308
//最小非零值
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;
// 位数
public static final int SIZE = 64;
// 字节数, jdk1.8新增属性
public static final int BYTES = SIZE / Byte.SIZE;
// Double类型class实例
@SuppressWarnings("unchecked")
public static final Class<Double> TYPE = (Class<Double>) Class.getPrimitiveClass("double");
//转换为String
public static String toString(double d) {
return FloatingDecimal.toJavaFormatString(d);
} //静态
public String toString() {
return toString(value);
} //实例,调用静态方法
/**
* 返回 double 参数的十六进制字符串表示形式
*/
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 < Double.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 ?
Double.MIN_EXPONENT:
Math.getExponent(d));
}
return answer.toString();
}
}
//根据参数返回新创建的Double对象,推荐使用这种构造器
public static Double valueOf(String s) throws NumberFormatException {
return new Double(parseDouble(s));
}
public static Double valueOf(double d) {
return new Double(d);
}
//根据String返回double基本类型值
public static double parseDouble(String s) throws NumberFormatException {
return FloatingDecimal.parseDouble(s);
}
//判断 double是否是无穷大 (正无穷或者负无穷)
public static boolean isInfinite(double v) {
return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
}
public boolean isInfinite() {
return isInfinite(value);
}
//判断double是都是有限的
public static boolean isFinite(double d) {
return Math.abs(d) <= Double.MAX_VALUE;
}
// 此包装类的基本类型值
private final double value;
//构造器,jdk9被废弃,new这种方式在jdk9之后都不推荐使用了,改用valueOf形式API
@Deprecated(since="9")
public Double(double value) {
this.value = value;
}
@Deprecated(since="9")
public Double(String s) throws NumberFormatException {
value = parseDouble(s);
}
//判断是否为NaN
public boolean isNaN() {
return isNaN(value);
}
public static boolean isNaN(double v) {
return (v != v); // NaN 与 NaN不相等
}
//基本类型转换
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;
}
@Override
public int hashCode() {
return Double.hashCode(value);
}
// jdk8新增方法
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) {
if (!isNaN(value)) {
return doubleToRawLongBits(value);
}
return 0x7ff8000000000000L; // NaN 固定为此值
}
public static native long doubleToRawLongBits(double value);
public static native double longBitsToDouble(long bits);
//比较大小
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; // 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)
}
// 求和, jdk8新增运算
public static double sum(double a, double b) {
return a + b;
}
//返回两个double中比较大的那个数,jdk8新增运算
public static double max(double a, double b) {
return Math.max(a, b);
}
//返回两个double中比较小的那个数,jdk8新增运算
public static double min(double a, double b) {
return Math.min(a, b);
}
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -9172774392245257468L;
四 Float类
Float和Double的源码基本上是一样的,这里不再多记录,可以参考Double的代码解析