Double (Java Platform SE 8 )

java.lang.Object
- java.lang.Number
- - java.lang.Double

All Implemented Interfaces:

Serializable ， Comparable < Double >
```
public final class Double
extends Number
implements Comparable<Double>
```
Double类包装一个对象中的原始类型double的值。类型为Double的对象包含一个单一字段，其类型为double 。
此外，该类还提供了几种将double转换为String和String转换为double ，以及在处理double时有用的其他常数和方法。

从以下版本开始：

JDK1.0

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`BYTES` 用于表示 `double`值的字节数。
`static int`	`MAX_EXPONENT` 最大指数有限的 `double`变量可能有。
`static double`	`MAX_VALUE` 的常量保持型的最大正的有限值 `double` ，（2-2 ^-52）A·2 ^1023。
`static int`	`MIN_EXPONENT` 最小指数归一化 `double`变量可能有。
`static double`	`MIN_NORMAL` 恒定持有 `double`类型的最小正正常值，2 ^-1022 。
`static double`	`MIN_VALUE` 一个常数保持最小的正非零值类型 `double` ^-1074 。
`static double`	`NaN` 一个常数，持有 `double`类型的非数字（NaN）值。
`static double`	`NEGATIVE_INFINITY` 持有 `double`类型的负无穷大的 `double` 。
`static double`	`POSITIVE_INFINITY` 恒定持有 `double`型的正无穷大。
`static int`	`SIZE` 用于表示 `double`值的位数。
`static 类<Double>`	`TYPE` `类`原始类型 `double`的 `类`实例。

构造方法摘要

构造方法
Constructor and Description
`Double(double value)` 构造一个新分配的 `Double`对象，表示原始 `double`参数。
`Double(String s)` 构造一个新分配 `Double`对象，它表示类型的浮点值 `double`用字符串表示。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`byte`	`byteValue()` 返回此值 `Double`为 `byte`的基本收缩转换后。
`static int`	`compare(double d1, double d2)` 比较两个指定的 `double`值。
`int`	`compareTo(Double anotherDouble)` 数字比较两个 `Double`对象。
`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()` 在 `int`后，返回 `Double`作为int的值。
`static boolean`	`isFinite(double d)` 如果参数是有限浮点值，则返回`true` ; 返回`false` （对于NaN和无穷大参数）。
`boolean`	`isInfinite()` 返回 `true`如果这 `Double`值是无限大， `false`其他。
`static boolean`	`isInfinite(double v)` 返回 `true`如果指定的数量是无限大， `false`其他。
`boolean`	`isNaN()` 如果 `Double`值 `Double`数字（NaN），则返回 `true` ， `false` false。
`static boolean`	`isNaN(double v)` 如果指定的数字是非数字（NaN）值，则返回 `true` ， `false` 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)` 返回一个新 `double`初始化为指定的代表的值 `String` ，如通过执行 `valueOf`类的方法 `Double` 。
`short`	`shortValue()` 返回此值 `Double`为 `short`的基本收缩转换后。
`static double`	`sum(double a, double b)` 按照+运算符将两个 `double`值一起添加。
`static String`	`toHexString(double d)` 返回 `double`参数的十六进制字符串 `double`形式。
`String`	`toString()` 返回此 `Double`对象的字符串表示形式。
`static String`	`toString(double d)` 返回 `double`参数的字符串 `double`形式。
`static Double`	`valueOf(double d)` 返回一个 `Double` `double`值的 `Double`实例。
`static Double`	`valueOf(String s)` 返回一个 `Double`对象，保存由参数字符串 `s`的 `double`值。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - POSITIVE_INFINITY
```
public static final double POSITIVE_INFINITY
```
    恒定持有double型的正无穷大。它等于Double.longBitsToDouble(0x7ff0000000000000L)返回的值。
    
    另请参见：
    
    Constant Field Values
  - NEGATIVE_INFINITY
```
public static final double NEGATIVE_INFINITY
```
    持有double类型的负无穷大的double 。它等于Double.longBitsToDouble(0xfff0000000000000L)返回的值。
    
    另请参见：
    
    Constant Field Values
  - NaN
```
public static final double NaN
```
    一个常数，持有double类型的非数字（NaN）值。它相当于返回的值Double.longBitsToDouble(0x7ff8000000000000L) 。
    
    另请参见：
    
    Constant Field Values
  - MAX_VALUE
```
public static final double MAX_VALUE
```
    的常量保持型的最大正的有限值double ，（2-2 ^-52）A·2 ^1023。它等于十六进制浮点数文字0x1.fffffffffffffP+1023 ，也等于Double.longBitsToDouble(0x7fefffffffffffffL) 。
    
    另请参见：
    
    Constant Field Values
  - MIN_NORMAL
```
public static final double MIN_NORMAL
```
    恒定持有double类型的最小正正常值，2 ^-1022 。它等于十六进制浮点数文字0x1.0p-1022 ，也等于Double.longBitsToDouble(0x0010000000000000L) 。
    
    从以下版本开始：
    
    1.6
    
    另请参见：
    
    Constant Field Values
  - MIN_VALUE
```
public static final double MIN_VALUE
```
    一个常数保持最小的正非零值类型double ^-1074 。它等于十六进制浮点数文字0x0.0000000000001P-1022 ，也等于Double.longBitsToDouble(0x1L) 。
    
    另请参见：
    
    Constant Field Values
  - MAX_EXPONENT
```
public static final int MAX_EXPONENT
```
    最大指数有限的double变量可能有。它等于Math.getExponent(Double.MAX_VALUE)返回的值。
    
    从以下版本开始：
    
    1.6
    
    另请参见：
    
    Constant Field Values
  - MIN_EXPONENT
```
public static final int MIN_EXPONENT
```
    最小指数归一化double变量可能有。它等于Math.getExponent(Double.MIN_NORMAL)返回的值。
    
    从以下版本开始：
    
    1.6
    
    另请参见：
    
    Constant Field Values
  - SIZE
```
public static final int SIZE
```
    用于表示 double值的位数。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    Constant Field Values
  - BYTES
```
public static final int BYTES
```
    用于表示 double值的字节数。
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    Constant Field Values
  - TYPE
```
public static final 类<Double> TYPE
```
    类原始类型 double的 类实例。
    
    从以下版本开始：
    
    JDK1.1
- 构造方法详细信息
  - Double
```
public Double(double value)
```
    构造一个新分配的 Double对象，代表原始的 double参数。
    
    参数
    
    value -值由表示 Double 。
  - Double
```
public Double(String s)
       throws NumberFormatException
```
    构造一个新分配的Double对象，该对象表示由字符串表示的类型double的浮点值。该字符串被转换为一个double值如果由valueOf方法。
    
    参数
    
    s -一个字符串被转换为 Double 。
    
    异常
    
    NumberFormatException - 如果字符串不包含可解析的数字。
    
    另请参见：
    
    valueOf(java.lang.String)
- 方法详细信息
  - toString
```
public static String toString(double d)
```
    返回double参数的字符串double形式。下面提到的所有字符都是ASCII字符。
    - 如果参数是NaN，结果是字符串“ NaN ”。
    - 否则，结果是表示参数的符号和大小（绝对值）的字符串。如果符号为负，则结果的第一个字符为' - '（ '\u002D' ）; 如果符号为正，则结果中不会出现任何符号字符。至于幅度m ：
      
      如果m是无穷大，它由字符"Infinity" ; 因此，正无穷大产生结果"Infinity"和负无穷大产生结果"-Infinity" 。
      
      如果m为零，则由"0.0" ; 因此，负零产生结果"-0.0" ，正零产生结果"0.0" 。
      
      如果m大于或等于10 ^-3但小于10 ⁷ ，则表示为m的整数部分，以十进制形式表示，不带前导零，后跟“ . ”（ '\u002E' ），后跟一个或多个表示m的小数部分十进制数字。
      
      如果m小于10 ^-3或大于或等于10 ⁷ ，则表示为所谓的“计算机科学记数法”。设n是唯一的整数，使得^10N的‰¤ 米 <10 ^{N + 1;} 然后让一个是m的精确算术商和10 ^牛顿，使1个â‰¤ 一个 <10.然后将大小被表示为a的整数部分，作为一个单一的十进制数字，后跟“ . ”（ '\u002E' ），再后面是表示一个小数部分十进制数字，后面跟有字母“ E ”（ '\u0045' ），接着为十进制整数n的表示，作为由该方法制备Integer.toString(int) 。
    m或a的小数部分必须打印多少位数？必须有至少一个数字来表示小数部分，并且除了必须唯一区分参数值和类型double相邻值所需的数量之外，还需要数量多的数字。也就是说，假设x是由用于有限非零参数d的该方法生成的十进制表示形式表示的精确数学值。那么d必须是最接近x的double值。或者如果两个double值同样接近x，那么d必须它们中的一个和d的有效数的至少显著位必须为0 。
    要创建浮点值的本地化字符串表示，请使用NumberFormat的子类。
    参数
    
    d -的 double进行转换。
    
    结果
    
    参数的字符串表示形式。
  - toHexString
```
public static String toHexString(double d)
```
    返回double参数的十六进制字符串double形式。下面提到的所有字符都是ASCII字符。
    - 如果参数是NaN，结果是字符串“ NaN ”。
    - 否则，结果是一个表示参数的符号和大小的字符串。如果符号为负，则结果的第一个字符为' - '（ '\u002D' ）; 如果符号为正，则结果中不会出现任何符号字符。至于幅度m ：
      
      如果m是无穷大，它由字符串"Infinity" ; 因此，正无穷大产生结果"Infinity"和负无穷大产生结果"-Infinity" 。
      
      如果m为零，则用字符串"0x0.0p0" ; 因此，负零产生结果"-0x0.0p0" ，正零产生结果"0x0.0p0" 。
      
      如果m是具有double一化表示的double值，则使用子字符串来表示有效位数和指数字段。有效数字由字符"0x1." "0x1."后面是有意义数据的其余部分的小写十六进制表示形式作为分数。删除十六进制表示中的尾随零，除非所有数字都为零，在这种情况下使用单个零。接下来，指数由"p"后跟无偏差指数的十进制字符串，就好像通过对指数值调用Integer.toString产生的那样。
      
      如果m是具有double表示的double值，则有效位数由字符"0x0."后面是有效数的其余部分的十六进制表示作为分数。删除十六进制表示中的尾随零。接下来，指数由"p-1022" 。请注意，在异常有效位数中必须至少有一个非零数字。
    Examples Floating-point Value Hexadecimal String 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中的前导和尾随空格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都在The Java™ Language Specification的词法结构部分中定义，但数字之间不接受下划线。如果s不具有的floatValue的形式，那么NumberFormatException异常。否则， s被认为是在通常的“计算机科学符号”中表示精确的十进制值，或者作为确切的十六进制值; 此确切数值然后被概念性地转换为一个“无限精确的”二进制值，然后将其倒圆的键入double由IEEE 754浮点运算，其包括保留0值的符号的通常舍入到最近的规则。注意，round-to-nearest规则也意味着溢出和下溢行为; 如果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); // 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(double)使用，因为该方法可能通过缓存经常请求的值而产生明显更好的空间和时间性能。
    
    参数
    
    d - 一个双重值。
    
    结果
    
    一个 Double实例，代表 d 。
    
    从以下版本开始：
    
    1.5
  - parseDouble
```
public static double parseDouble(String s)
                          throws NumberFormatException
```
    返回一个新的 double ，由Double的 valueOf方法 String ，初始化为由指定的 valueOf的 Double 。
    
    参数
    
    s - 要解析的字符串。
    
    结果
    
    double值由字符串参数表示。
    
    异常
    
    NullPointerException - 如果字符串为空
    
    NumberFormatException - 如果字符串不包含可解析的 double 。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    valueOf(String)
  - isNaN
```
public static boolean isNaN(double v)
```
    如果指定的数字是非数字（NaN）值，则返回 true ， false false。
    
    参数
    
    v - 要测试的值。
    
    结果
    
    true如果参数的值是NaN; false否则。
  - isInfinite
```
public static boolean isInfinite(double v)
```
    返回 true如果指定的数量是无限大， false其他。
    
    参数
    
    v - 要测试的值。
    
    结果
    
    true如果参数的值是正无穷大或负无穷大; false否则。
  - isFinite
```
public static boolean isFinite(double d)
```
    如果参数是有限浮点值，则返回true ; 返回false （对于NaN和无穷大参数）。
    
    参数
    
    d - 要测试的 double值
    
    结果
    
    true如果参数是一个有限浮点值， false否则。
    
    从以下版本开始：
    
    1.8
  - isNaN
```
public boolean isNaN()
```
    返回 true如果这 Double值是不是非数字（NAN）， false其他。
    
    结果
    
    true如果该对象表示的值为NaN; false否则。
  - isInfinite
```
public boolean isInfinite()
```
    返回 true如果这个 Double数值无限大， false false。
    
    结果
    
    true如果该对象表示的值是正无穷大或负无穷大; false否则。
  - toString
```
public String toString()
```
    返回此Double对象的字符串表示形式。由该对象表示的double值double转换为一个字符串，如同一个参数的方法toString 。
    
    重写：
    
    toString在类别 Object
    
    结果
    
    一个 String表示的这个对象。
    
    另请参见：
    
    toString(double)
  - byteValue
```
public byte byteValue()
```
    返回此值 Double为 byte的基本收缩转换后。
    
    重写：
    
    byteValue在类别 Number
    
    结果
    
    double值由此对象表示转换为 byte
    
    从以下版本开始：
    
    JDK1.1
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - shortValue
```
public short shortValue()
```
    返回此值 Double为 short的基本收缩转换后。
    
    重写：
    
    shortValue在类别 Number
    
    结果
    
    由此对象代表的 double值转换为 short
    
    从以下版本开始：
    
    JDK1.1
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - intValue
```
public int intValue()
```
    返回此的值 Double作为 int的基本收缩转换之后。
    
    Specified by:
    
    intValue在类别 Number
    
    结果
    
    double值由此对象表示转换为 int型
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - longValue
```
public long longValue()
```
    返回此值 Double为 long的基本收缩转换后。
    
    Specified by:
    
    longValue在类别 Number
    
    结果
    
    所述 double该对象表示值转换为类型 long
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - floatValue
```
public float floatValue()
```
    返回此值 Double为 float的基本收缩转换后。
    
    Specified by:
    
    floatValue在类别 Number
    
    结果
    
    所述 double该对象表示值转换为类型 float
    
    从以下版本开始：
    
    JDK1.0
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - doubleValue
```
public double doubleValue()
```
    返回此 Double对象的 double值。
    
    Specified by:
    
    doubleValue在类别 Number
    
    结果
    
    double由此对象 double值
  - hashCode
```
public int hashCode()
```
    返回此Double对象的哈希码。结果是long整数位表示的两半的异或，正如由方法doubleToLongBits(double)所产生的，由这个Double对象表示的原始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值被认为是相同的。
    请注意，在大多数情况下，类的两个实例Double ， d1和d2 ，值d1.equals(d2)是true当且仅当
    
    d1.doubleValue() == d2.doubleValue()
    
    也有值true 。但是，有两个例外：
    - 如果d1和d2都代表Double.NaN ，那么equals方法返回true ，即使Double.NaN==Double.NaN的值为false 。
    - 如果d1表示+0.0 ，而d2表示-0.0 ，反之亦然， equal测试值为false ，即使+0.0==-0.0的值为true 。
    此定义允许哈希表正常运行。
    重写：
    
    equals在类别 Object
    
    参数
    
    obj - 要比较的对象。
    
    结果
    
    true如果对象是一样的; false否则。
    
    另请参见：
    
    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表示相对应的double值。该参数被认为是根据IEEE 754浮点“双格式”位布局的浮点值的表示。
    如果参数是0x7ff0000000000000L ，结果是正无穷大。
    
    如果参数为0xfff0000000000000L ，结果为负无穷大。
    
    如果参数在上述范围内的任何值0x7ff0000000000001L通过0x7fffffffffffffffL ，或在范围0xfff0000000000001L通过0xffffffffffffffffL ，其结果是NaN。 Java提供的IEEE 754浮点运算不能用不同的位模式区分同一类型的两个NaN值。 NaN的不同值只能通过使用Double.doubleToRawLongBits方法进行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可能无法返回一个double具有signaling NaN的位模式。因此，对于一些long值， doubleToRawLongBits(longBitsToDouble(start))可能不等于start 。此外，哪些特定位模式表示信令NaN是平台依赖的; 尽管所有NaN位模式，安静或信令都必须位于上面确定的NaN范围内。
    参数
    
    bits - 任何 long整数。
    
    结果
    
    double具有相同位模式的浮点值。
  - compareTo
```
public int compareTo(Double anotherDouble)
```
    数字比较两个Double对象。当应用于原始double值时，通过此方法进行比较的方式与Java语言数值比较运算符（ <, <=, ==, >=, > ）执行的比较有两种double ：
    - Double.NaN被认为是等于本身并且大于所有其他double值（包括Double.POSITIVE_INFINITY ）。
    - 0.0d被认为是大于-0.0d 。
    这确保了这种方法施加的Double对象的自然排序 与equals一致 。
    Specified by:
    
    compareTo在界面 Comparable<Double>
    
    参数
    
    anotherDouble - 要比较的 Double 。
    
    结果
    
    0如果anotherDouble在数字上等于这个Double ; 一个值小于0如果这个Double在数字上小于anotherDouble ; 如果这个Double大于0那么这个值大于anotherDouble 。
    
    从以下版本开始：
    
    1.2
  - compare
```
public static int compare(double d1,
                          double d2)
```
    比较两个指定的double值。返回的整数值的符号与调用返回的整数的符号相同：
```
  new Double(d1).compareTo(new Double(d2)) 
```
    参数
    
    d1 - 第一个 double进行比较
    
    d2 - 第二个 double进行比较
    
    结果
    
    0如果d1在数字上等于d2 ; 的值小于0如果d1在数值上小于d2 ; 如果d1在数值上大于0则值大于d2 。
    
    从以下版本开始：
    
    1.4
  - sum
```
public static double sum(double a,
                         double b)
```
    根据+运算符将两个 double值一起添加。
    
    参数
    
    a - 第一个操作数
    
    b - 第二个操作数
    
    结果
    
    总和 a和 b
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    BinaryOperator
    
    See The Java™ Language Specification:
    
    4.2.4浮点运算
  - max
```
public static double max(double a,
                         double b)
```
    返回两个 double的较大值，就像调用 Math.max一样。
    
    参数
    
    a - 第一个操作数
    
    b - 第二个操作数
    
    结果
    
    a和 b
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    BinaryOperator
  - min
```
public static double min(double a,
                         double b)
```
    返回两个 double的较小值，就像调用 Math.min一样。
    
    参数
    
    a - 第一个操作数
    
    b - 第二个操作数
    
    结果
    
    较小的 a和 b 。
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    BinaryOperator

Class Double

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

字段详细信息

POSITIVE_INFINITY

NEGATIVE_INFINITY

NaN

MAX_VALUE

MIN_NORMAL

MIN_VALUE

MAX_EXPONENT

MIN_EXPONENT

SIZE

BYTES

TYPE

构造方法详细信息

Double

Double

方法详细信息

toString

toHexString

valueOf

valueOf

parseDouble

isNaN

isInfinite

isFinite

isNaN

isInfinite

toString

byteValue

shortValue

intValue

longValue

floatValue

doubleValue

hashCode

hashCode

equals

doubleToLongBits

doubleToRawLongBits

longBitsToDouble

compareTo

compare

sum

max

min