模块 java.base

包 java.lang

类 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 时有用的其他常量和方法。

这是一个value-based类；程序员应该将 equal 的实例视为可互换的，并且不应使用实例进行同步，否则可能会发生不可预测的行为。例如，在未来的版本中，同步可能会失败。

浮点相等、等价和比较

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

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

值得注意的是，对浮点值的内置 == 运算是 not 等价关系。尽管没有定义等价关系，但 IEEE 754 == 运算符的语义是有意设计的，以满足数值计算的其他需求。 == 对浮点值不满足等价关系的属性有两个例外：

• 如果 v1 和 v2 均为 NaN，则 v1 == v2 的值为 false。因此，对于两个 NaN 参数，等价关系的 reflexive 属性是 not 由 == 运算符满足的。
• 如果 v1 表示 +0.0 而 v2 表示 -0.0 ，反之亦然，则 v1 == v2 的值为 true，即使 +0.0 和 -0.0 在各种浮点运算中是可区分的。例如，1.0/+0.0 的计算结果为正无穷大，而 1.0/-0.0 的计算结果为 negative 无穷大，正无穷大和负无穷大既不相等也不等价。因此，虽然带符号的零输入最常决定零结果的符号，但由于除以零，+0.0 和 -0.0 通常不能相互替换。零输入的符号对某些数学库方法的结果也有不可替代的影响。

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

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

equals 和 compareTo 的操作语义是根据 按位转换 浮点值到整数值来表示的。

compareTo 实现的 natural ordering 是 一致 。也就是说，当且仅当这些对象上的 compareTo 返回零时，equals 将两个对象报告为相等。

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

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

数量相等 (== 运算符): (Not 等价关系)

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

逐位等价:

两个浮点值的位相同。 double 值 a 和 b 的等价关系由表达式实现
Double.doubleTo Raw LongBits(a) == Double.doubleTo Raw LongBits(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 浮点运算标准
• Serialized Form

字段摘要

字段

修饰符和类型	Field	描述
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 实例。

构造方法总结

构造方法

构造方法	描述
Double(double value)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 使用此构造方法很少是合适的。
Double(String s)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 使用此构造方法很少是合适的。

方法总结

修饰符和类型	方法	描述
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 浮点“双精度格式”位布局返回指定浮点值的表示形式。
static long	doubleToRawLongBits(double value)	根据 IEEE 754 浮点“双精度格式”位布局返回指定浮点值的表示形式，保留非数字 (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 值。
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)	返回一个新的 double 初始化为由指定的 String 表示的值，由类 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)	返回一个 Double 对象，其中包含由参数字符串 s 表示的 double 值。

在类 java.lang.Object 中声明的方法

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

字段详细信息

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 值的有效位数中的位数。这是 4.2.3 节中的参数 NJava 语言规范.

自从：

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 的 Class 实例。

自从：

1.1

构造方法详细信息

Double

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

已弃用，将被删除：此 API 元素可能会在未来版本中删除。

使用此构造函数很少是合适的。静态工厂 valueOf(double) 通常是更好的选择，因为它可能会产生更好的空间和时间性能。

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

参数：

value - Double 表示的值。

Double

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

已弃用，将被删除：此 API 元素可能会在未来版本中删除。

使用此构造函数很少是合适的。使用 parseDouble(String) 将字符串转换为 double 基元，或使用 valueOf(String) 将字符串转换为 Double 对象。

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

参数：

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

抛出：

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

方法详情

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是积极的和有限的。它分两个阶段转换为字符串：
    • Selection of a decimal：定义明确的小数d_m被选中代表m.这个小数（几乎总是）四舍五入到的 shortestm根据 IEEE 754 浮点算法的舍入到最近舍入策略。
    • Formatting as a string：十进制d_m被格式化为一个字符串，可以是普通的，也可以是计算机化的科学记数法，这取决于它的值。

A decimal 是形式的数字s×10ⁱ对于一些（唯一的）整数s> 0 和i这样s不是 10 的倍数。这些整数分别是小数的 significand 和 exponent 。小数的length是（唯一的）正整数n会议 10^n-1≤s < 10ⁿ.

小数点d_m对于有限正数m定义如下：

• 让R是舍入到的所有小数的集合m根据 IEEE 754 浮点运算的通常 round to nearest 舍入策略。
• 让p是所有小数的最小长度R.
• 什么时候p≥ 2, 让T是所有小数的集合R有长度p.否则，让T是所有小数的集合R长度为 1 或 2。
• 定义d_m作为小数点T这是最接近m.或者如果有两个这样的小数T选择具有偶数尾数的那个。

（唯一）选定的小数d_m然后被格式化。让s, i和n是有效数，指数和长度d_m， 分别。进一步，让e = n + i1 让s₁……s_n是通常的十进制扩展s.注意s₁≠ 0 和s_n≠ 0。下面，小数点'.'为'\u002E'，指数指标'E'为'\u0045'。

• 情况-3≤e < 0: d_m格式为 0.0 …0s₁……s_n, 其中恰好有 -(n + i) 小数点和之间的零s₁.例如，123×10^-4格式为 0.0123 。
• 情况 0 ≤e < 7:
  • 子案例i≥ 0:d_m格式为s₁……s_n0 …0.0 ，那里正好有i之间的零s_n和小数点。例如，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₁.0E e.例如，1 × 10²³格式为 1.0E23 。
  • 子案例n > 1: d_m格式为s₁. s₂……s_nE e.例如，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
Minimum Normal Value	0x1.0p-1022
Maximum Subnormal Value	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如词法语法规则所述：

浮动值：

符号_选择 NaN

符号_选择 Infinity

符号_选择 FloatingPointLiteral

符号_选择 HexFloatingPointLiteral

SignedInteger

HexFloatingPointLiteral:

HexSignificand BinaryExponent FloatTypeSuffix_选择

十六进制有效数：

HexNumeral

HexNumeral .

0x HexDigits_选择 . HexDigits

0X HexDigits_选择 . HexDigits

二进制指数：

BinaryExponentIndicator 有符号整数

二进制指数指标：

p

P

在哪里符号, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger和FloatTypeSuffix是在词法结构部分中定义的Java 语言规范, 除了数字之间不接受下划线。如果 s 没有 a 的形式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，not 等同于将字符串直接转换为 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); // Will not throw NumberFormatException
 else {
   // Perform suitable alternative action
 }
 

参数：

s - 要解析的字符串。

返回：

一个 Double 对象保存由 String 参数表示的值。

抛出：

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

valueOf

public static Double  valueOf(double d)
            

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

参数：

d - 双重值。

返回：

代表 d 的 Double 实例。

自从：

1.5

parseDouble

public static double parseDouble(String  s) throws NumberFormatException 
            

返回一个新的 double 初始化为由指定的 String 表示的值，由类 Double 的 valueOf 方法执行。

参数：

s - 要解析的字符串。

返回：

字符串参数表示的 double 值。

抛出：

NullPointerException - 如果字符串为空

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

自从：

1.2

参见：

• valueOf(String)

isNaN

public static boolean isNaN(double v)
            

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

API 注意：

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

参数：

v - 要测试的值。

返回：

true 如果参数的值为 NaN； 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。

返回：

true如果这个对象表示的值是NaN； 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 对象的哈希码。结果是 long 整数位表示的两半的异或，与此 Double 对象表示的原始 double 值的方法 doubleToLongBits(double) 完全相同。也就是说，哈希码是表达式的值：

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

其中 v 定义为：

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

重写：

hashCode 在类 Object 中

返回：

此对象的 hash code 值。

参见：

• 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)
            

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

重写：

equals 在类 Object 中

API 注意：

此方法是根据 doubleToLongBits(double) 而不是 double 值上的 == 运算符定义的，因为 == 运算符确实 not 定义了等价关系并且要满足 等于合同 必须实现等价关系；有关浮点相等和等价的详细信息，请参见 这个讨论。

参数：

obj - 要比较的参考对象。

返回：

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

看Java 语言规范:

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

参见：

• doubleToLongBits(double)

doubleToLongBits

public static long doubleToLongBits(double value)
            

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

第 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 浮点“双精度格式”位布局返回指定浮点值的表示形式，保留非数字 (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 浮点“双精度格式”位布局，该参数被认为是浮点值的表示。

如果参数为 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，安静 NaN 和信号 NaN.这两种 NaN 之间的差异在 Java 中通常是看不出来的。对信号 NaN 的算术运算将它们变成具有不同但通常相似的位模式的安静 NaN。但是，在某些处理器上，仅复制信令 NaN 也会执行该转换。特别是，复制信号 NaN 以将其返回给调用方法可能会执行此转换。因此 longBitsToDouble 可能无法返回带有信令 NaN 位模式的 double。因此，对于某些 long 值，doubleToRawLongBits(longBitsToDouble(start)) 可能not等于 start 。此外，哪些特定的位模式表示信号 NaN 是平台相关的；尽管所有 NaN 位模式，安静或信号，都必须在上面标识的 NaN 范围内。

参数：

bits - 任何 long 整数。

返回：

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

compareTo

public int compareTo(Double  anotherDouble)
            

在数值上比较两个 Double 对象。与 Java 语言数值比较运算符 (<, <=, ==, >=, >) 对 double 值定义的不完整顺序相比，此方法对 Double 对象施加总顺序，有两个不同之处。

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

这确保了自然排序此方法强加的 Double 个对象是一致;有关浮点比较和排序的详细信息，请参阅 这个讨论。

指定者：

compareTo 在接口 Comparable<Double> 中

参数：

anotherDouble - 要比较的 Double。

返回：

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

看Java 语言规范:

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

自从：

1.2

compare

public static int compare(double d1, double d2)
            

比较两个指定的 double 值。返回的整数值的符号与调用返回的整数的符号相同：

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

参数：

d1 - 第一个要比较的 double

d2 - 要比较的第二个 double

返回：

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

自从：

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

参见：

• BinaryOperator

max

public static double max(double a, double b)
            

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

API 注意：

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

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a 和 b 中的较大者

自从：

1.8

参见：

• BinaryOperator

min

public static double min(double a, double b)
            

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

API 注意：

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

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a 和 b 中较小的一个。

自从：

1.8

参见：

• BinaryOperator

describeConstable

public Optional <Double > describeConstable()
            

返回一个 Optional ，其中包含此实例的标称描述符，即实例本身。

指定者：

describeConstable 在接口 Constable 中

返回：

Optional 描述了 Double 实例

自从：

12

resolveConstantDesc

public Double  resolveConstantDesc(MethodHandles.Lookup  lookup)
            

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

指定者：

resolveConstantDesc 在接口 ConstantDesc 中

参数：

lookup - 忽略

返回：

Double 实例

自从：

12