Module java.base

Package java.lang

Class Double

java.lang.Object

java.lang.Number

java.lang.Double

所有已实现的接口:

Serializable, Comparable<Double>, Constable, ConstantDesc

       public final class Double extends Number implements Comparable<Double>, Constable, ConstantDesc
      

Double类将原始类型double的值封装在对象中。类型为Double的对象包含一个字段，其类型为double。

此外，该类提供了几种方法，用于将double转换为String，将String转换为double，以及在处理double时使用的其他常量和方法。

这是一个基于值的类；程序员应将相等的实例视为可互换的，并且不应将实例用于同步，否则可能会导致不可预测的行为。例如，在将来的版本中，同步可能会失败。

浮点数相等性、等价性和比较

IEEE 754浮点数值包括有限非零值、有符号零（+0.0和-0.0）、有符号无穷大（正无穷大和负无穷大）以及NaN（非数值）。

在一组值上的一个等价关系是一种布尔关系，适用于值对，具有自反性、对称性和传递性。有关等价关系和对象相等性的更多讨论，请参阅Object.equals规范。等价关系将其操作的值划分为称为等价类的集合。等价类的所有成员在关系下彼此相等。等价类可能只包含单个成员。至少对于某些目的，等价类的所有成员可以互相替换。特别是，在数值表达式中，等价值可以互相替换，而不会改变表达式的结果，这意味着改变表达式的结果的等价类。

值得注意的是，浮点数值的内置==操作不是一个等价关系。尽管没有定义等价关系，IEEE 754的==运算符的语义是经过故意设计以满足数值计算的其他需求。有两种情况，浮点数值的==操作不满足等价关系的属性：

• 如果v1和v2都是NaN，则v1 == v2的值为false。因此，对于两个NaN参数，==运算符的自反性属性不被==运算符满足。
• 如果v1表示+0.0，而v2表示-0.0，或者反之，则v1 == v2的值为true，即使+0.0和-0.0在各种浮点运算中是可区分的。例如，1.0/+0.0求值为正无穷大，而1.0/-0.0求值为负无穷大，正无穷大和负无穷大既不相等也不等价于彼此。因此，尽管有符号零输入通常确定零结果的符号，但由于除以零，+0.0和-0.0通常不能互换。零输入的符号还会对某些数学库方法的结果产生不可替代的影响。

使用内置比较运算符（<、<=等）进行有序比较时，NaN值存在另一个异常情况：NaN既不小于、也不大于、也不等于任何值，包括自身。这意味着比较的三分法不成立。

为了为equals和compareTo方法提供适当的语义，这些方法不能简单地是==或有序比较操作的包装器。相反，equals使用表示等价性，将NaN参数定义为相等，恢复自反性，并定义+0.0与-0.0 不相等。对于比较，compareTo定义了一个总序，其中-0.0小于+0.0，而NaN等于自身，并被认为大于正无穷大。

equals和compareTo的操作语义是以将浮点数值转换为整数值的位转换来表达的。

由compareTo实现的自然排序与equals一致。也就是说，如果两个对象通过compareTo返回零，则equals将报告这两个对象相等。

为equals和compareTo定义的调整行为允许包装类的实例与传统数据结构正常工作。例如，将NaN值定义为equals互相等价允许NaN用作HashSet的元素或HashMap的键。类似地，将compareTo定义为包括+0.0、-0.0和NaN的总排序，允许包装类的实例用作SortedSet的元素或SortedMap的键。

将数值相等性与可以定义在浮点数值上的各种有用等价关系进行比较：

数值相等性（==运算符）：（不是一个等价关系）

两个浮点数值表示相同的扩展实数。扩展实数是实数与正无穷大和负无穷大的扩展。在数值相等性下，+0.0和-0.0是相等的，因为它们都映射到相同的实数值0。NaN不映射到任何实数，也不等于任何值，包括自身。

位等价性:

两个浮点数值的位是相同的。对于double值a和b，此等价关系由表达式实现
Double.doubleToRawLongBits(a) == Double.doubleToRawLongBits(b)
在此关系下，+0.0和-0.0是可区分的，每个编码NaN的位模式与每个编码NaN的其他位模式都是可区分的。

表示等价性:

两个浮点数值表示相同的IEEE 754 数据。特别地，对于有限值，浮点数值的符号、指数和尾数组件是相同的。在此关系下：

• +0.0和-0.0是可区分的。
• 每个编码NaN的位模式被认为是等价的
• 正无穷大等价于正无穷大；负无穷大等价于负无穷大。

实现此等价关系的表达式包括：

• Double.doubleToLongBits(a) == Double.doubleToLongBits(b)
• Double.valueOf(a).equals(Double.valueOf(b))
• Double.compare(a, b) == 0

请注意，表示等价性通常是测试数学库行为的适当等价性概念。

对于两个二进制浮点数值a和b，如果a和b都不是零或NaN，则a和b的数值相等性、位等价性和表示等价性的三个关系具有相同的true/false值。换句话说，对于二进制浮点数值，只有在至少一个参数为零或NaN时，这三个关系才会有所不同。

参见Java语言规范:

4.2.3 浮点类型、格式和值
4.2.4 浮点运算
15.21.1 数值相等性运算符 == 和 !=
15.20.1 数值比较运算符 <, <=, >, 和 >=

自版本:

1.0

另请参见:

• IEEE浮点算术标准
• 序列化形式

Field Summary

Fields

Modifier and Type	Field	Description
static final int	BYTES	用于表示double值的字节数。
static final int	MAX_EXPONENT	有限double变量可能具有的最大指数。
static final double	MAX_VALUE	一个常量，保存类型为double的最大正有限值，(2-2-52)·21023。
static final int	MIN_EXPONENT	规范化double变量可能具有的最小指数。
static final double	MIN_NORMAL	一个常量，保存类型为double的最小正规值，2-1022。
static final double	MIN_VALUE	一个常量，保存类型为double的最小正非零值，2-1074。
static final double	NaN	一个常量，保存类型为double的非数值（NaN）值。
static final double	NEGATIVE_INFINITY	一个常量，保存类型为double的负无穷大。
static final double	POSITIVE_INFINITY	一个常量，保存类型为double的正无穷大。
static final int	PRECISION	double值的尾数中的位数。
static final int	SIZE	用于表示double值的位数。
static final Class<Double>	TYPE	表示原始类型double的Class实例。

Constructor Summary

Constructors

Constructor	Description
Double(double value)	已弃用，将来会移除：此API元素可能在将来的版本中被移除。 很少适合使用此构造函数。
Double(String s)	已弃用，将来会移除：此API元素可能在将来的版本中被移除。 很少适合使用此构造函数。

Method Summary

Modifier and Type	Method	Description
byte	byteValue()	返回此Double的值作为缩小的原始转换后的byte。
static int	compare(double d1, double d2)	比较两个指定的double值。
int	compareTo(Double anotherDouble)	按数字比较两个Double对象。
Optional<Double>	describeConstable()	返回包含此实例的名义描述符的Optional，即实例本身。
static long	doubleToLongBits(double value)	根据IEEE 754浮点“double格式”位布局返回指定浮点值的表示。
static long	doubleToRawLongBits(double value)	根据IEEE 754浮点“double格式”位布局返回指定浮点值的表示，保留非数字（NaN）值。
double	doubleValue()	返回此Double对象的double值。
boolean	equals(Object obj)	将此对象与指定对象进行比较。
float	floatValue()	返回此Double的值作为缩小的原始转换后的float。
int	hashCode()	返回此Double对象的哈希码。
static int	hashCode(double value)	返回double值的哈希码；与Double.hashCode()兼容。
int	intValue()	返回此Double的值作为缩小的原始转换后的int。
static boolean	isFinite(double d)	如果参数是有限浮点值，则返回true；否则返回false（对于NaN和无穷大参数）。
boolean	isInfinite()	如果此Double值在大小上是无穷大，则返回true；否则返回false。
static boolean	isInfinite(double v)	如果指定的数字在大小上是无穷大，则返回true；否则返回false。
boolean	isNaN()	如果此Double值是非数字（NaN），则返回true；否则返回false。
static boolean	isNaN(double v)	如果指定的数字是非数字（NaN）值，则返回true；否则返回false。
static double	longBitsToDouble(long bits)	返回给定位表示的double值对应的double值。
long	longValue()	返回此Double的值作为缩小的原始转换后的long。
static double	max(double a, double b)	返回两个double值中较大的值，就像调用Math.max一样。
static double	min(double a, double b)	返回两个double值中较小的值，就像调用Math.min一样。
static double	parseDouble(String s)	返回由指定String表示的值初始化的新double，类似于Double类的valueOf方法执行的操作。
Double	resolveConstantDesc(MethodHandles.Lookup lookup)	将此实例解析为ConstantDesc，其结果是实例本身。
short	shortValue()	返回此Double的值作为缩小的原始转换后的short。
static double	sum(double a, double b)	将两个double值相加，就像使用+运算符一样。
static String	toHexString(double d)	返回double参数的十六进制字符串表示。
String	toString()	返回此Double对象的字符串表示。
static String	toString(double d)	返回double参数的字符串表示。
static Double	valueOf(double d)	返回表示指定double值的Double实例。
static Double	valueOf(String s)	返回持有由参数字符串s表示的double值的Double对象。

Methods declared in class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Details

POSITIVE_INFINITY

             public static final double POSITIVE_INFINITY
            

一个持有double类型的正无穷大的常量。它等于Double.longBitsToDouble(0x7ff0000000000000L)返回的值。

参见：

• 常量字段值

NEGATIVE_INFINITY

             public static final double NEGATIVE_INFINITY
            

一个持有double类型的负无穷大的常量。它等于Double.longBitsToDouble(0xfff0000000000000L)返回的值。

参见：

• 常量字段值

NaN

             public static final double NaN
            

一个持有double类型的非数字（NaN）值的常量。它等于Double.longBitsToDouble(0x7ff8000000000000L)返回的值。

参见：

• 常量字段值

MAX_VALUE

             public static final double MAX_VALUE
            

一个持有double类型的最大正有限值的常量，(2-2^-52)·2¹⁰²³。它等于十六进制浮点文字0x1.fffffffffffffP+1023，也等于Double.longBitsToDouble(0x7fefffffffffffffL)。

参见：

• 常量字段值

MIN_NORMAL

             public static final double MIN_NORMAL
            

一个持有double类型的最小正规值的常量，2^-1022。它等于十六进制浮点文字0x1.0p-1022，也等于Double.longBitsToDouble(0x0010000000000000L)。

自：

1.6

参见：

• 常量字段值

MIN_VALUE

             public static final double MIN_VALUE
            

一个持有double类型的最小正非零值的常量，2^-1074。它等于十六进制浮点文字0x0.0000000000001P-1022，也等于Double.longBitsToDouble(0x1L)。

参见：

• 常量字段值

SIZE

             public static final int SIZE
            

用于表示double值的位数。

自：

1.5

参见：

• 常量字段值

PRECISION

             public static final int PRECISION
            

用于表示double值中尾数的位数。这是The Java Language Specification第4.2.3节中的参数N。

自：

19

参见：

• 常量字段值

MAX_EXPONENT

             public static final int MAX_EXPONENT
            

有限double变量可能具有的最大指数。它等于Math.getExponent(Double.MAX_VALUE)返回的值。

自：

1.6

参见：

• 常量字段值

MIN_EXPONENT

             public static final int MIN_EXPONENT
            

规范化的double变量可能具有的最小指数。它等于Math.getExponent(Double.MIN_NORMAL)返回的值。

自：

1.6

参见：

• 常量字段值

BYTES

             public static final int BYTES
            

用于表示double值的字节数。

自：

1.8

参见：

• 常量字段值

TYPE

             public static final Class<Double> TYPE
            

表示double值所使用的位数。

自：

1.1

Constructor Details

Double

             @Deprecated(since="9", forRemoval=true) public Double(double value)
            

Deprecated, for removal: This API element is subject to removal in a future version.

It is rarely appropriate to use this constructor. The static factory valueOf(double) is generally a better choice, as it is likely to yield significantly better space and time performance.

构造一个新分配的Double对象，表示原始double参数。

参数：

value - 要由Double表示的值。

Double

             @Deprecated(since="9", forRemoval=true) public Double(String s) throws NumberFormatException
            

Deprecated, for removal: This API element is subject to removal in a future version.

It is rarely appropriate to use this constructor. Use parseDouble(String) to convert a string to a double primitive, or use valueOf(String) to convert a string to a Double object.

构造一个新分配的Double对象，表示由字符串表示的double类型的浮点值。字符串将被转换为double值，就像通过valueOf方法一样。

参数：

s - 要转换为Double的字符串。

抛出：

NumberFormatException - 如果字符串不包含可解析的数字。

Method Details

toString

             public static String toString(double d)
            

返回double参数的字符串表示。下面提到的所有字符都是ASCII字符。

• 如果参数是NaN，则结果是字符串"NaN"。
• 否则，结果是一个表示参数的符号和大小（绝对值）的字符串。如果符号为负，则结果的第一个字符是'-'（'\u002D'）；如果符号为正，则结果中不会出现符号字符。至于大小m：
  • 如果m是无穷大，则用字符串"Infinity"表示；因此，正无穷大产生结果"Infinity"，负无穷大产生结果"-Infinity"。
  • 如果m为零，则用字符串"0.0"表示；因此，负零产生结果"-0.0"，正零产生结果"0.0"。
  • 否则m为正且有限。它被转换为一个字符串分为两个阶段：
    • 选择小数：选择一个明确定义的小数d_m来表示m。这个小数（几乎总是）是最接近的一个，根据IEEE 754浮点算术的四舍五入到最近的规则，四舍五入到m。
    • 格式化为字符串：小数d_m被格式化为一个字符串，根据其值，可以是普通的或计算机化的科学记数法。

一个小数是形式为s×10ⁱ的数字，其中s > 0和i是不是10的倍数的唯一整数。这些整数分别是小数的尾数和指数。小数的长度是满足10^n-1 ≤ s < 10ⁿ的（唯一的）正整数n。

有限正数m的小数d_m定义如下：

• 令R为所有四舍五入到m的小数的集合，根据IEEE 754浮点算术的通常四舍五入到最近规则。
• 令p为所有R中小数的最小长度。
• 当p ≥ 2时，令T为长度为p的所有R中的小数的集合。否则，令T为长度为1或2的所有R中的小数的集合。
• 将d_m定义为T中最接近m的小数。或者如果T中有两个这样的小数，则选择尾数为偶数的那个。

然后格式化（唯一）选择的小数d_m。令s、i和n分别为尾数、指数和长度，e = n + i - 1，令s₁…s_n为s的常规小数展开。注意s₁ ≠ 0且s_n ≠ 0。下面，小数点'.'为'\u002E'，指数标识符'E'为'\u0045'。

• 情况 -3 ≤ e < 0：将d_m格式化为0.0…0s₁…s_n，小数点和s₁之间恰好有-（n + i）个零。例如，123 × 10^-4格式化为0.0123。
• 情况 0 ≤ e < 7：
  • 子情况 i ≥ 0：将d_m格式化为s₁…s_n0…0.0，s_n和小数点之间恰好有i个零。例如，123 × 10²格式化为12300.0。
  • 子情况 i < 0：将d_m格式化为s₁…s_n+i.s_n+i+1…s_n，小数点右边恰好有-i个数字。例如，123 × 10^-1格式化为12.3。
• 情况 e < -3或e ≥ 7：使用计算机化科学记数法格式化d_m。这里e由Integer.toString(int)格式化。
  • 子情况 n = 1：将d_m格式化为s₁.0Ee。例如，1 × 10²³格式化为1.0E23。
  • 子情况 n > 1：将d_m格式化为s₁.s₂…s_nEe。例如，123 × 10^-21格式化为1.23E-19。

NumberFormat的子类。

参数：

d - 要转换的double。

返回：

参数的字符串表示。

toHexString

             public static String toHexString(double d)
            

返回double参数的十六进制字符串表示。下面提到的所有字符都是ASCII字符。

• 如果参数是NaN，则结果是字符串"NaN"。
• 否则，结果是一个表示参数的符号和大小的字符串。如果符号为负，则结果的第一个字符是'-'（'\u002D'）；如果符号为正，则结果中不会出现符号字符。至于大小m：
  • 如果m是无穷大，则用字符串"Infinity"表示；因此，正无穷大产生结果"Infinity"，负无穷大产生结果"-Infinity"。
  • 如果m为零，则用字符串"0x0.0p0"表示；因此，负零产生结果"-0x0.0p0"，正零产生结果"0x0.0p0"。
  • 如果m是具有规范化表示的double值，则使用子字符串来表示尾数和指数字段。尾数由字符"0x1."表示，后跟其余尾数的小写十六进制表示作为分数。十六进制表示中的尾随零将被移除，除非所有数字都为零，在这种情况下将使用一个零。接下来，指数由"p"表示，后跟无偏指数的十进制字符串，就像通过调用Integer.toString产生的那样。
  • 如果m是具有次正规表示的double值，则尾数由字符"0x0."表示，后跟其余尾数的十六进制表示作为分数。十六进制表示中的尾随零将被移除。接下来，指数由"p-1022"表示。请注意，次正规尾数中必须至少有一个非零数字。

示例

浮点值	十六进制字符串
1.0	0x1.0p0
-1.0	-0x1.0p0
2.0	0x1.0p1
3.0	0x1.8p1
0.5	0x1.0p-1
0.25	0x1.0p-2
Double.MAX_VALUE	0x1.fffffffffffffp1023
最小正规值	0x1.0p-1022
最大次正规值	0x0.fffffffffffffp-1022
Double.MIN_VALUE	0x0.0000000000001p-1022

参数：

d - 要转换的double。

返回：

参数的十六进制字符串表示。

自：

1.5

valueOf

             public static Double valueOf(String s) throws NumberFormatException
            

返回一个Double对象，该对象包含由参数字符串s表示的double值。

如果s为null，则会抛出NullPointerException异常。

s中的前导和尾随空格字符将被忽略。空格将被移除，就像通过String.trim()方法一样；也就是说，ASCII空格和控制字符都将被移除。其余的s应符合词法语法规则描述的FloatValue：

FloatValue:

Sign_opt NaN

Sign_opt Infinity

Sign_opt FloatingPointLiteral

Sign_opt HexFloatingPointLiteral

SignedInteger

HexFloatingPointLiteral:

HexSignificand BinaryExponent FloatTypeSuffix_opt

HexSignificand:

HexNumeral

HexNumeral .

0x HexDigits_opt . HexDigits

0X HexDigits_opt . HexDigits

BinaryExponent:

BinaryExponentIndicator SignedInteger

BinaryExponentIndicator:

p

P

其中Sign、FloatingPointLiteral、HexNumeral、HexDigits、SignedInteger和FloatTypeSuffix的定义在Java语言规范的词法结构部分中，不接受数字之间的下划线。如果s不符合FloatValue的形式，则会抛出NumberFormatException异常。否则，s被视为表示通常的“计算机科学记数法”中的精确十进制值或精确十六进制值；然后，将这个精确的数值概念上转换为“无限精确”的二进制值，然后按照IEEE 754浮点算术的通常四舍五入规则将其舍入为double类型，其中包括保留零值的符号。请注意，四舍五入规则还意味着溢出和下溢行为；如果s的确切值在大小上足够大（大于或等于（MAX_VALUE + ulp(MAX_VALUE)/2），舍入为double将导致无穷大，如果s的确切值在大小上足够小（小于或等于MIN_VALUE/2），舍入为浮点数将导致零。最后，返回表示这个double值的Double对象。

要解释浮点值的本地化字符串表示形式，请使用NumberFormat的子类。

请注意，尾随格式说明符，确定浮点文字类型的说明符（1.0f是一个float值；1.0d是一个double值），不会影响此方法的结果。换句话说，输入字符串的数值将直接转换为目标浮点类型。两步转换序列，从字符串到float，然后从float到double，并不等同于直接将字符串转换为double。例如，float文字0.1f等于double值0.10000000149011612；float文字0.1f表示的数值与double文字0.1表示的数值不同。（数值0.1无法在二进制浮点数中精确表示。）

为了避免在无效字符串上调用此方法并抛出NumberFormatException，可以使用下面的正则表达式来筛选输入字符串：

 final String Digits     = "(\\p{Digit}+)";
 final String HexDigits  = "(\\p{XDigit}+)";
 // an exponent is 'e' or 'E' followed by an optionally
 // signed decimal integer.
 final String Exp        = "[eE][+-]?"+Digits;
 final String fpRegex    =
     ("[\\x00-\\x20]*"+  // Optional leading "whitespace"
      "[+-]?(" + // Optional sign character
      "NaN|" +           // "NaN" string
      "Infinity|" +      // "Infinity" string

      // A decimal floating-point string representing a finite positive
      // number without a leading sign has at most five basic pieces:
      // Digits . Digits ExponentPart FloatTypeSuffix
      //
      // Since this method allows integer-only strings as input
      // in addition to strings of floating-point literals, the
      // two sub-patterns below are simplifications of the grammar
      // productions from section 3.10.2 of
      // The Java Language Specification.

      // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt
      "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+

      // . Digits ExponentPart_opt FloatTypeSuffix_opt
      "(\\.("+Digits+")("+Exp+")?)|"+

      // Hexadecimal strings
      "((" +
       // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt
       "(0[xX]" + HexDigits + "(\\.)?)|" +

       // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt
       "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +

       ")[pP][+-]?" + Digits + "))" +
      "[fFdD]?))" +
      "[\\x00-\\x20]*");// Optional trailing "whitespace"
 if (Pattern.matches(fpRegex, myString))
     Double.valueOf(myString); // 不会抛出NumberFormatException
 else {
     // 执行适当的替代操作
 }

参数：

s - 要解析的字符串。

返回：

包含由String参数表示的值的Double对象。

抛出：

NumberFormatException - 如果字符串不包含可解析的数字。

valueOf

             public static Double valueOf(double d)
            

返回表示指定double值的Double实例。如果不需要新的Double实例，则通常应优先使用此方法，而不是构造函数Double(double)，因为此方法可能通过缓存频繁请求的值而获得显着更好的空间和时间性能。

参数：

d - 一个double值。

返回：

表示d的Double实例。

自：

1.5

parseDouble

             public static double parseDouble(String s) throws NumberFormatException
            

返回一个新的double，其值由指定的String表示，类似于Double类的valueOf方法执行的操作。

参数：

s - 要解析的字符串。

返回：

由字符串参数表示的double值。

抛出：

NullPointerException - 如果字符串为null

NumberFormatException - 如果字符串不包含可解析的double。

自：

1.2

参见：

• valueOf(String)

isNaN

             public static boolean isNaN(double v)
            

如果指定的数字是非数字（NaN）值，则返回true，否则返回false。

API注释：

此方法对应于IEEE 754中定义的isNaN操作。

参数：

v - 要测试的值。

返回：

如果参数的值为NaN，则返回true；否则返回false。

isInfinite

             public static boolean isInfinite(double v)
            

如果指定的数字在大小上是无限大的，则返回true，否则返回false。

API注释：

此方法对应于IEEE 754中定义的isInfinite操作。

参数：

v - 要测试的值。

返回：

如果参数的值为正无穷大或负无穷大，则返回true；否则返回false。

isFinite

             public static boolean isFinite(double d)
            

如果参数是有限浮点值，则返回true；否则返回false（对于NaN和无穷大参数）。

API注释：

此方法对应于IEEE 754中定义的isFinite操作。

参数：

d - 要测试的double值

返回：

如果参数是有限浮点值，则返回true；否则返回false。

自：

1.8

isNaN

             public boolean isNaN()
            

如果此Double值是非数字（NaN），则返回true；否则返回false。

返回：

如果此对象表示的值为NaN，则返回true；否则返回false。

isInfinite

             public boolean isInfinite()
            

如果此Double值在大小上是无限大的，则返回true；否则返回false。

返回：

如果此对象表示的值为正无穷大或负无穷大，则返回true；否则返回false。

toString

             public String toString()
            

返回此Double对象的字符串表示形式。由此对象表示的基本double值将被转换为字符串，就像通过一个参数的toString方法一样。

覆盖：

toString 在类 Object中

返回：

此对象的String表示形式。

参见：

• toString(double)

byteValue

             public byte byteValue()
            

返回此Double值作为byte的值，经过缩小的原始类型转换。

覆盖：

byteValue 在类 Number中

返回：

将此对象表示的double值转换为byte类型的值

参见 Java语言规范：

5.1.3 缩小原始转换

自：

1.1

shortValue

             public short shortValue()
            

返回此Double的值作为缩小原始转换后的short值。

覆盖：

shortValue 在类 Number中

返回：

将此对象表示的double值转换为short类型的值

参见 Java语言规范：

5.1.3 缩小原始转换

自：

1.1

intValue

             public int intValue()
            

返回此Double的值作为缩小原始转换后的int值。

指定者：

intValue 在类 Number中

返回：

将此对象表示的double值转换为int类型的值

参见 Java语言规范：

5.1.3 缩小原始转换

longValue

             public long longValue()
            

返回此Double的值作为缩小原始转换后的long值。

指定者：

longValue 在类 Number中

返回：

将此对象表示的double值转换为long类型的值

参见 Java语言规范：

5.1.3 缩小原始转换

floatValue

             public float floatValue()
            

返回此Double的值作为缩小原始转换后的float值。

指定者：

floatValue 在类 Number中

API 注意：

此方法对应于IEEE 754中定义的convertFormat操作。

返回：

将此对象表示的double值转换为float类型的值

参见 Java语言规范：

5.1.3 缩小原始转换

自：

1.0

doubleValue

             public double doubleValue()
            

返回此Double对象的double值。

指定者：

doubleValue 在类 Number中

返回：

将此对象表示的double值

hashCode

             public int hashCode()
            

返回此Double对象的哈希码。结果是由该对象表示的原始double值的两个半部分的异或运算结果，正如由方法doubleToLongBits(double)产生的那样，其中double值由此Double对象表示。也就是说，哈希码是以下表达式的值：

(int)(v^(v>>>32))

其中v由以下定义：

long v = Double.doubleToLongBits(this.doubleValue());

覆盖：

hashCode 在类 Object中

返回：

该对象的哈希码值。

参见：

• Object.equals(java.lang.Object)
• System.identityHashCode(java.lang.Object)

hashCode

             public static int hashCode(double value)
            

返回double值的哈希码；与Double.hashCode()兼容。

参数：

value - 要哈希的值

返回：

double值的哈希码值。

自：

1.8

equals

             public boolean equals(Object obj)
            

将此对象与指定对象进行比较。结果仅在参数不为null且为表示与此对象表示的double具有相同值的Double对象时为true。对此，仅当应用于每个值时方法doubleToLongBits(double)返回相同的long值时，才认为两个double值相同。

覆盖：

equals 在类 Object中

API 注意：

此方法根据doubleToLongBits(double)而不是==运算符定义，因为==运算符不定义等价关系，为满足equals合同必须实现等价关系；有关浮点数相等性和等价性的详细信息，请参见此讨论。

参数：

obj - 要比较的引用对象。

返回：

如果此对象与obj参数相同，则为true；否则为false。

参见 Java语言规范：

15.21.1 数值等式运算符 == 和 !=

参见：

• doubleToLongBits(double)

doubleToLongBits

             public static long doubleToLongBits(double value)
            

根据IEEE 754浮点“double格式”位布局返回指定浮点值的表示。

第63位（由掩码0x8000000000000000L选择的位）表示浮点数的符号。位62-52（由掩码0x7ff0000000000000L选择的位）表示指数。位51-0（由掩码0x000fffffffffffffL选择的位）表示浮点数的尾数（有时称为尾数）。

如果参数为正无穷大，则结果为0x7ff0000000000000L。

如果参数为负无穷大，则结果为0xfff0000000000000L。

如果参数为NaN，则结果为0x7ff8000000000000L。

在所有情况下，结果是一个long整数，当传递给longBitsToDouble(long)方法时，将产生与doubleToLongBits的参数相同的浮点值（除了所有NaN值都被折叠为单个“规范”NaN值）。

参数：

value - 一个double精度浮点数。

返回：

表示浮点数的位。

doubleToRawLongBits

             public static long doubleToRawLongBits(double value)
            

根据IEEE 754浮点“double格式”位布局返回指定浮点值的表示，保留非数值（NaN）值。

第63位（由掩码0x8000000000000000L选择的位）表示浮点数的符号。位62-52（由掩码0x7ff0000000000000L选择的位）表示指数。位51-0（由掩码0x000fffffffffffffL选择的位）表示浮点数的尾数（有时称为尾数）。

如果参数为正无穷大，则结果为0x7ff0000000000000L。

如果参数为负无穷大，则结果为0xfff0000000000000L。

如果参数为NaN，则结果是表示实际NaN值的long整数。与doubleToLongBits方法不同，doubleToRawLongBits不会将所有编码NaN的位模式折叠为单个“规范”NaN值。

在所有情况下，结果是一个long整数，当传递给longBitsToDouble(long)方法时，将产生与doubleToRawLongBits的参数相同的浮点值。

参数：

value - 一个double精度浮点数。

返回：

表示浮点数的位。

自：

1.3

longBitsToDouble

             public static double longBitsToDouble(long bits)
            

返回与给定位表示对应的double值。根据IEEE 754浮点“double格式”位布局，参数被视为浮点值的表示形式。

如果参数是0x7ff0000000000000L，结果是正无穷大。

如果参数是0xfff0000000000000L，结果是负无穷大。

如果参数在范围0x7ff0000000000001L到0x7fffffffffffffffL或在范围0xfff0000000000001L到0xffffffffffffffffL内的任何值，则结果是NaN。Java提供的任何IEEE 754浮点操作都无法区分具有不同位模式的相同类型的两个NaN值。 NaN的不同值只能通过使用Double.doubleToRawLongBits方法来区分。

在所有其他情况下，让s，e和m是可以从参数计算出的三个值：

int s = ((bits >> 63) == 0) ? 1 : -1;
int e = (int)((bits >> 52) & 0x7ffL);
long m = (e == 0) ?
                (bits & 0xfffffffffffffL) << 1 :
                (bits & 0xfffffffffffffL) | 0x10000000000000L;

然后浮点结果等于数学表达式s·m·2^e-1075。

请注意，此方法可能无法返回具有与long参数完全相同位模式的double NaN。 IEEE 754区分两种NaN，quiet NaN和signaling NaNs。这两种NaN之间的差异通常在Java中不可见。对signaling NaN的算术操作将其转换为具有不同但通常相似的位模式的quiet NaN。但是，在某些处理器上，仅复制signaling NaN也执行该转换。特别是，复制signaling NaN以将其返回给调用方法可能执行此转换。因此，longBitsToDouble可能无法返回具有signaling NaN位模式的double。因此，对于某些long值，doubleToRawLongBits(longBitsToDouble(start))可能不等于start。此外，表示signaling NaN的特定位模式是平台相关的；尽管所有NaN位模式，无论是quiet还是signaling，都必须在上面标识的NaN范围内。

参数：

bits - 任何long整数。

返回：

具有相同位模式的double浮点值。

compareTo

             public int compareTo(Double anotherDouble)
            

数值比较两个Double对象。此方法对double值施加了一个总序，与Java语言数值比较运算符（<, <=, ==, >=, >）在double值上定义的不完全序有两个差异。

• NaN在与其他值的比较中是无序的，并且在比较运算符下不等于自身。此方法选择定义 Double.NaN等于自身且大于所有其他double值（包括 Double.POSITIVE_INFINITY）。
• 正零和负零在数值上比较相等，但是是不同且可区分的值。此方法选择定义正零（+0.0d）大于负零（-0.0d）。

这确保了由此方法施加的Double对象的自然排序与等同一致；有关浮点比较和排序的详细信息，请参见此讨论。

指定者：

compareTo 在接口 Comparable<Double>

参数：

anotherDouble - 要比较的Double。

返回：

如果anotherDouble在数值上等于此Double，则返回值为0；如果此Double在数值上小于anotherDouble，则返回值小于0；如果此Double在数值上大于anotherDouble，则返回值大于0。

参见Java语言规范：

15.20.1 数值比较运算符<, <=, >, 和 >=

自1.2起：

1.2

compare

             public static int compare(double d1, double d2)
            

比较两个指定的double值。返回的整数值的符号与通过调用以下方法返回的整数值的符号相同：

    Double.valueOf(d1).compareTo(Double.valueOf(d2))
 

参数：

d1 - 要比较的第一个double

d2 - 要比较的第二个double

返回：

如果d1在数值上等于d2，则返回值为0；如果d1在数值上小于d2，则返回值小于0；如果d1在数值上大于d2，则返回值大于0。

自1.4起：

1.4

sum

             public static double sum(double a, double b)
            

将两个double值相加，就像使用+运算符一样。

API注释：

此方法对应于IEEE 754中定义的加法操作。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a和b的和

参见Java语言规范：

4.2.4 浮点运算

自1.8起：

1.8

另请参见：

• BinaryOperator

max

             public static double max(double a, double b)
            

返回两个double值中较大的值，就像调用Math.max一样。

API注释：

此方法对应于IEEE 754中定义的最大操作。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a和b中较大的值

自1.8起：

1.8

另请参见：

• BinaryOperator

min

             public static double min(double a, double b)
            

返回两个double值中较小的值，就像调用Math.min一样。

API注释：

此方法对应于IEEE 754中定义的最小操作。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a和b中较小的值。

自1.8起：

1.8

另请参见：

• BinaryOperator

describeConstable

             public Optional<Double> describeConstable()
            

返回包含此实例的名义描述符的Optional，即实例本身。

指定者：

describeConstable 在接口 Constable

返回：

描述Double实例的Optional

自12起：

12

resolveConstantDesc

             public Double resolveConstantDesc(MethodHandles.Lookup lookup)
            

将此实例解析为ConstantDesc，其结果是实例本身。

指定者：

resolveConstantDesc 在接口 ConstantDesc

参数：

lookup - 忽略

返回：

Double实例

自12起：

12