1.概述
Double类是基本类型double的包装类。double 双精度浮点数在内存内占 8 个字节,用 64 位二进制描述。
2.类图
继承了Number类,可以用于数字类型的一系列转换
实现了Comparable接口,可以用于比较
实现了序列化接口,用于序列化和反序列
3.属性
- 静态常量,可直接通过类名.来调用
public static final double POSITIVE_INFINITY = 1.0 / 0.0;//正无穷
public static final double NEGATIVE_INFINITY = -1.0 / 0.0;//负无穷
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;//标准化的最小值
public static final double MIN_VALUE = 0x0.0000000000001P-1022;//double 类型数据能够保持的最小正非零值的常量。
public static final int MAX_EXPONENT = 1023;//指数真值的有效的最大值
public static final int MIN_EXPONENT = -1022;//指数真值的有效的最小值
public static final int SIZE = 64;//用秦以二进制补码形式表示 double 值的比特位数
public static final int BYTES = SIZE / Byte.SIZE;//二进制补码形式表示 double 值的字节数
public static final Class<Double> TYPE = (Class<Double>) Class.getPrimitiveClass("double");//基本类型 double 的 Class 实例。
- 私有变量
private final double value;//用来保存这个类包装的double的数值
4.构造方法
- Double(double value) 将double封装成Double对象
public Double(double value) {
this.value = value;
}
- Double(String s) 将String解析成double,再将其封装成Double对象
public Double(String s) throws NumberFormatException {
value = parseDouble(s);
}
5.常用方法
-
toString/toHexString
将double转为String输出
public static String toString(double d) {
return FloatingDecimal.toJavaFormatString(d);
}
public String toString() {
return toString(value);
}
返回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) )
// 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);
// 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();
}
}
-
valueOf
-
public static Double valueOf(String s)
将String解析成double,然后调用构造函数包装成Double返回
public static Double valueOf(String s) throws NumberFormatException { return new Double(parseDouble(s)); }
b. public static Double valueOf(double d)
将double 封装成Double
public static Double valueOf(double d) { return new Double(d); }
-
-
isXXX
-
public static boolean isNaN(double v)
- 只有传入的值为NaN才为true
public static boolean isNaN(double v) { return (v != v); }
-
public static boolean isInfinite(double v)
- 只有传入的值为正无穷或负无穷才为true
public static boolean isInfinite(double v) { return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY); }
-
public static boolean isFinite(double d)
- 判断是不是在double的范围内
public static boolean isFinite(double d) { return Math.abs(d) <= DoubleConsts.MAX_VALUE; }
-
public boolean isNaN() 判断是不是NaN的实例方法
- 内部调用静态方法isNaN
public boolean isNaN() { return isNaN(value); }
-
public boolean isInfinite() 判断是不是正负无穷的实例方法
- 内部调用静态方法isInfinite
public boolean isInfinite() { return isInfinite(value); }
-
-
XXXValue
- public byte byteValue() 将value强转为byte
- public short shortValue() 将value强转为short
- public int intValue() 将value强转为int
- public long longValue() 将value强转为long
- public float floatValue() 将value强转为float
- public double doubleValue() 直接返回value
-
hashCode
-
public int hashCode() 实例方法 内部调用静态方法Double.hashCode(value);
public int hashCode() { return Double.hashCode(value); } public static int hashCode(double value) { long bits = doubleToLongBits(value); return (int)(bits ^ (bits >>> 32)) }
-
-
equals
public boolean equals(Object obj) { return (obj instanceof Double) // 比较转换后的long类型是否相同 && (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);
-
compareTo
- 判断两个double变量值严格相等,一般会直接用double_x == double_y来做比较,这样做一般没有问题,但是如果本意是比较两个浮点数对象是否相同(double_x == double_y是比较两个对象值是否严格相同),对象相同和值严格相等是不一样的,原因是java遵循IEEE 754浮点数标准,在这个标准中规定NaN与任何值比较皆不等,如果double_x与double_y的值都是NaN,这个时候他们是相同的对象,但double_x == double_y会返回false。解决方法是,判断浮点数对象是否相同,要用Double.doubleToLongBits将double值转换过后再比较
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 // 转换成long再比较是否相等 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) }
这是一个例子 结果如下
直接比较NaN的话 是不相等。但是若封装成对象在比较则是相等的。
6.其他方法
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);
}