JDK1.8源码学习--lang包(Double)
前言
月是一轮明镜,晶莹剔透,代表着一张白纸(啥也不懂)
央是一片海洋,海乃百川,代表着一块海绵(吸纳万物)
泽是一柄利剑,千锤百炼,代表着千百锤炼(输入输出)
月央泽,学习的一种过程,从白纸->吸收各种知识->不断输入输出变成自己的内容
希望大家一起坚持这个过程,也同样希望大家最终都能从零到零,把知识从薄变厚,再由厚变薄!
一.Double的作用:
直接看源码注释(我的翻译可能不太准,如果道友们有更棒的理解,可以留言或者私信)
/**
* The {@code Double} class wraps a value of the primitive type
* {@code double} in an object. An object of type
* {@code Double} contains a single field whose type is
* {@code double}.
* 1.Double类将原始类型 double的值包装在一个对象中。Double类型的对象包含一个类型为 double的字段
* In addition, this class provides several methods for converting a
* {@code double} to a {@code String} and a
* {@code String} to a {@code double}, as well as other
* constants and methods useful when dealing with a
* {@code double}.
* 2.此外，该类提供了几种将 double转换为 String和将 String转换为 double的方法，以及在处理double
* @author Lee Boynton
* @author Arthur van Hoff
* @author Joseph D. Darcy
* @since JDK1.0
*/
二.Double的类图:
a).一个Comparable,这个接口对实现他的每个对象都可按照一定的规则来进行排序,详情请点击下面链接
JDK1.8源码学习--lang包(Comparable)_w5_Silence的博客-CSDN博客
b).Secializable,这个接口是可为实现的对象进行序列化,详情请点击下面链接
......(假装这个是链接,以后补充)
c).Numer,这个抽象类对一些数字操作进行了相关规范
JDK1.8源码学习--lang包(Number)_w5_Silence的博客-CSDN博客
三.成员变量:
/**
* 保持类型的正无穷大的常数
*/
public static final double POSITIVE_INFINITY = 1.0 / 0.0;
/**
* //保持类型的负无穷大的常数
*/
public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
/**
* 保存类型为非数字 (NaN) 值的常量
*/
public static final double NaN = 0.0d / 0.0;
/**
* 保持最大正有限值类型的常数
*/
public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308
/**
* Double.MIN_NORMAL是您可以表示的最小可能数
* @since 1.6
*/
public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308
/**
* Double.MIN_VALUE基本上是您可以在没有此约束的情况下表示的最小数字
*/
public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324
/**
* 有限 double变量可能具有的最大指数。
*/
public static final int MAX_EXPONENT = 1023;
/**
* 标准化double变量可能具有的最小指数。它等于返回的值
*/
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实例
*/
public static final Class TYPE = (Class) Class.getPrimitiveClass("double");
/**
* Double 的值l
*/
private final double value; 四.构造方法:
/**t.
* 构造一个新分配的 Double对象，表示原始double参数
*/
public Double(double value) {
this.value = value;
}
/**
* 1.构造一个新分配的 Double对象，该对象表示由字符串表示的double类型的浮点值。
* 字符串被转换为 double值，就像通过 valueOf方法一样
*/
public Double(String s) throws NumberFormatException {
value = parseDouble(s);
}
五.内部方法:
toString()
当double的值小于10的-3次方或者大于10的7次方,会以科学计数法的方式放回其字符串形式表示
/**
* 1.返回 double参数的字符串表示形式。下面提到的所有字符都是ASCII字符
* 2.如果参数为NaN，则结果为字符串“NaN”,否则，结果是一个字符串，表示参数的符号和大小（绝对值）。
* 如果符号为负，则结果的第一个字符为'-'；如果符号为正，则结果中不出现符号字符。
* 3.至于幅度m：
* 1)如果m为无穷大，则用字符"Infinity"表示；
* 因此，正无穷产生结果 "Infinity"，负无穷产生结果 "-Infinity"。
* 如果m为零，则用字符"0.0"表示；因此，负零产生结果"-0.0"，正零产生结果"0.0"
* 2)如果m大于等于10-3但小于107，
* 则表示为m，十进制形式，没有前导零，后跟'.'，后跟一个或多个十进制数字，代表m的小数部分
* 3)如果m小于10-3或大于或等于107，则用所谓的“计算机科学记数法”表示。
* 令 n为唯一整数，满足 10n ≤ m {@literal <} 10n< i>+1;
* 然后让 a成为 m和 10n 的数学上精确商，使得 1 ≤a { <} 10.
* 然后将幅度表示为 a的整数部分，作为单个十进制数字，后跟 '.'，
* 然后是由十进制数字表示 a的小数部分，后跟字母 'E'，后跟 n的表示作为十进制整数，
* 由方法 Integer.toString(int)产生
* 4).m或 a的小数部分必须打印多少位数字？必须至少有一个数字来表示小数部分，
* 并且超过这个数字，但只能是唯一地将参数值与double类型的相邻值区分开来所需的数字。
* 也就是说，假设x是由此方法为有限非零参数 d生成的十进制表示所表示的精确数学值。
* 那么d必须是最接近x的double值；或者如果两个double值同样接近x，
* 则 d必须是其中之一，并且是 d的有效数的最低有效位必须是0
* 4.要创建浮点值的本地化字符串表示，请使用java.text.NumberFormat的子类
*/
public static String toString(double d) {
return FloatingDecimal.toJavaFormatString(d);
}toHexString()
/**
* 1.返回 double参数的十六进制字符串表示形式。
* 2.下面提到的所有字符都是ASCII字符:
* 1)如果参数是 NaN，则结果是字符串 "NaN"
* 2)否则，结果是一个字符串，表示参数的符号和大小。
* 如果符号为负，则结果的第一个字符为'-' ；如果符号为正，则结果中不出现符号字符
* 3.至于幅度m:
* 1)如果m是无穷大，则用字符串 "Infinity"表示；因此，正无穷产生结果"Infinity"，
* 负无穷产生结果"-Infinity"
* 2)如果 m为零，则由字符串 "0x0.0p0"表示；因此，负零产生结果 "-0x0.0p0"，
* 正零产生结果 "0x0.0p0"
* 3)如果m是具有标准化表示的double 值，则子字符串用于表示有效数和指数字段。
* 有效数由字符 "0x1."表示，后跟有效数其余部分的小写十六进制表示形式。
* 除非所有数字都为零，否则将删除十六进制表示中的尾随零，在这种情况下使用单个零。
* 接下来，指数由"p"后跟无偏指数的十进制字符串表示，就像通过对指数值调用
* Integer.toString(int)产生的一样
* 4)如果m 是具有次正规表示的 double 值，则有效数由字符 "0x0."表示，
* 后跟有效数其余部分的十六进制表示作为分数.十六进制表示中的尾随零被删除。
* 接下来，指数由 "p-1022"表示。请注意，次正规有效数中必须至少有一个非零数字
*/
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.
//对于无穷大和 NaN，使用十进制输出
return Double.toString(d);
else {
//初始化为最大输出大小
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);
//隔离高位中的有效位和 OR，以便字符串表示具有已知长度
long signifBits = (Double.doubleToLongBits(d)
& DoubleConsts.SIGNIF_BIT_MASK) |
0x1000000000000000L;
//次正规值有一个 0 隐含位；正常值有 1 个隐式位
answer.append(subnormal ? "0." : "1.");
//隔离十六进制表示的低 13 位数字。
// 如果所有数字都为零，则替换为单个 0；否则，删除所有尾随零
String signif = Long.toHexString(signifBits).substring(3,16);
answer.append(signif.equals("0000000000000") ? // 13 zeros
"0":
signif.replaceFirst("0{1,12}$", ""));
answer.append('p');
//如果该值低于正常值，则对 double 使用 E_min 指数值；
// 否则，提取并报告 d 的指数（次正规的表示使用 E_min -1）
answer.append(subnormal ?
DoubleConsts.MIN_EXPONENT:
Math.getExponent(d));
}
return answer.toString();
}
}valueOf()
/
* 1.返回一个Double对象，其中包含由参数字符串s表示的double值
* 2.如果 s为 null，则抛出NullPointerException。
* 3.s中的前导和尾随空白字符将被忽略。像 String.trim方法一样删除空格；
* 也就是说，ASCII 空格和控制字符都被删除了,其余的 s应该构成一个FloatValue，
* 4.其中Sign、FloatingPointLiteral、HexNumeral、HexDigits、SignedInteger
* 和 FloatTypeSuffix为在Java™ 语言规范的词法结构部分中定义，除了数字之间不接受下划线
* 5.如果 s不具有 FloatValue的形式，则抛出 NumberFormatException
* 6.否则，s被视为表示通常的“计算机化科学记数法”中的精确十进制值或精确的十六进制值；
* 然后，这个精确的数值在概念上被转换为一个“无限精确”的二进制值，
* 然后通过 IEEE 754 浮点运算的通常舍入到最近的规则舍入到类型 double，其中包括保留一个零值
*
* 7.请注意，舍入到最近的规则还暗示上溢和下溢行为
* 8.如果 s的确切值在数量级上足够大（大于或等于 MAX_VALUE+ Math.ulp(double)），
* 四舍五入到 double将导致无穷大，
* 9.如果 s 的确切值在数量级上足够小（小于或等于 MIN_VALUE，四舍五入为浮点数将导致零
* 10.最后，在四舍五入后返回表示此 double值的 Double对象
* 11.要解释浮点值的本地化字符串表示，请使用java.text.NumberFormat的子类
* 11.请注意尾随格式说明符，确定浮点文字类型的说明符（1.0f是一个 float 值；
* 1.0d是一个 double值），请执行不影响本方法的结果
* 12.换句话说，输入字符串的数值直接转换为目标浮点类型
* 13.两步转换序列，字符串到 float，然后是 float到double，不等效于将字符串直接转换为 double
* 14.例如，float文字 0.1f 等于 double值 0.10000000149011612；float文字 0.1f表示与 double文字 0.1不同的数值。
* （数值 0.1 不能用二进制浮点数精确表示。
* 15.为了避免在无效字符串上调用此方法并抛出NumberFormatException，
* 可以使用下面的正则表达式来筛选输入字符串
*/
public static Double valueOf(String s) throws NumberFormatException {
return new Double(parseDouble(s));
}
/**
* 1.返回表示指定的 double值的 Double实例。
* 2.如果不需要新的Double实例，则通常应优先使用此方法而不是构造函数 Double(double)，
* 因为此方法可能会通过缓存频繁请求的内容来显着提高空间和时间性能值
*/
public static Double valueOf(double d) {
return new Double(d);
parseDouble(String s)
/**
* 返回一个新的 double，初始化为由指定的 String表示的值，
* 由 Double类的 valueOf法执行
*/
public static double parseDouble(String s) throws NumberFormatException {
return FloatingDecimal.parseDouble(s);
}isNaN(double b)
/**
* 1.如果指定的数字是非数字 (NaN) 值，则返回 true，否则返回false
*/
public static boolean isNaN(double v) {
return (v != v);
}isInfinite(double v)
/**
* 如果指定数字的大小无限大，则返回 true，否则返回 false
*/
public static boolean isInfinite(double v) {
return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
}
isFinite
/**
* 如果参数是有限浮点值，则返回true；否则返回false对于 NaN 和无穷大参数
*/
public static boolean isFinite(double d) {
return Math.abs(d) <= DoubleConsts.MAX_VALUE;
}原始类型的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;
}关于hash方面的方法:
/**
* 1.返回此Double对象的哈希码
* 2.结果是 long整数位表示的两半的异或，与方法 doubleToLongBits(double)
* 产生的完全一样，由这个 表示的原始double值代码 Double对象(int)(v^(v>>>32))
*/
@Override
public int hashCode() {
return Double.hashCode(value);
}
/**
* 1.返回双精度值的哈希码；与 Double.hashCode() 兼容
*/
public static int hashCode(double value) {
long bits = doubleToLongBits(value);
return (int)(bits ^ (bits >>> 32));
}
/**
* 1.根据 IEEE 754 浮点“双格式”位布局返回指定浮点值的表示
* 2.第 63 位（由掩码 0x8000000000000000L选择的位）表示浮点数的符号
* 3.第 62-52 位（掩码0x7ff0000000000000L 选择的位）代表指数
* 4.位 51-0（由掩码 0x000fffffffffffffL 选择的位）表示浮点数的有效数（有时称为尾数）
* 5.如果参数为正无穷大，则结果为 0x7ff0000000000000L
* 6.如果参数为负无穷大，则结果为 0xfff0000000000000L
* 7.如果参数为 NaN，则结果为 0x7ff8000000000000L
* 8.在所有情况下，结果都是一个 long整数，当给longBitsToDouble(long)方法时，
* 将产生一个与 doubleToLongBits的参数相同的浮点值（除了所有 NaN 值都折叠为单个“规范”NaN 值）
*/
public static long doubleToLongBits(double value) {
long result = doubleToRawLongBits(value);
// Check for NaN based on values of bit fields, maximum
// exponent and nonzero significand.
//根据位字段的值、最大指数和非零有效数检查 NaN
if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
DoubleConsts.EXP_BIT_MASK) &&
(result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
result = 0x7ff8000000000000L;
return result;
}equals(Object obj)
/**
* 1.将此对象与指定的对象进行比较
* 2.结果是 true当且仅当参数不是 null并且是一个 Double对象，
* 该对象表示与 double具有相同值的 double由这个对象表示
* 3.为此，当且仅当方法 doubleToLongBits(double)
* 在应用于每个时返回相同的 long 值时，才认为两个double值相同
* 4.请注意，在大多数情况下，对于Double类d1和d2的两个实例，
* d1.equals(d2)的值是 true如果并且仅当 d1.doubleValue() == d2.doubleValue()
* 也有值 true。
* 5.但是，有两个例外:
* 1)如果 d1和 d2都表示Double.NaN，那么equals方法返回 true，即使 Double.NaN==Double.NaN的值为 false。
* 2)如果 d1代表 +0.0 而d2代表-0.0，反之亦然，equal测试的值为false，即使 +0.0==-0.0的值为 true
*/
public boolean equals(Object obj) {
return (obj instanceof Double)
&& (doubleToLongBits(((Double)obj).value) ==
doubleToLongBits(value));
}compare
/**
* 1.以数字方式比较两个Double对象。此方法执行的比较与 Java 语言数值比较运算符
* (<, <=, ==, >=, >) 执行的比较有两种不同之处
* 2.当应用于原始 double 值时：
* 此方法认为 Double.NaN等于自身并大于所有其他double值（包括 Double.POSITIVE_INFINITY}。
* 0.0d被此方法认为大于 -0.0d
* 3.这确保了此方法强加的 Double对象的自然顺序与 equals一致
*/
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.
//由于 NaN 的可能性，不能使用 doubleToRawLongBits
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)
}
add
/**
* 根据 + 运算符将两个double值相加
*/
public static double sum(double a, double b) {
return a + b;
}
max
/**
* 返回两个 double值中的较大者，就像调用 Math.max(double, double)
*/
public static double max(double a, double b) {
return Math.max(a, b);
}min
/**
* 返回两个 double值中较小的一个，就像通过调用 Math.min(double, double)
*/
public static double min(double a, double b) {
return Math.min(a, b);
}
六.总结
Double应该算是比较轻松的一个数字类