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}）·2 ^{一千零二十三}。
`static int`	`MIN_EXPONENT` 最低指数归一化 `double`变可能。
`static double`	`MIN_NORMAL` 恒持正的最小正常值类型 `double`，2 ^{- 1022}。
`static double`	`MIN_VALUE` 恒持正的最小非零的值的类型 `double`，2 ^{- 1074}。
`static double`	`NaN` 恒持非数字（NaN） `double`型价值。
`static double`	`NEGATIVE_INFINITY` 一个恒定的持有型 `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()` 作为一个窄化转换后 `byte`返回该 `Double`价值。
`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()` 作为一个窄化转换后 `float`返回该 `Double`价值。
`int`	`hashCode()` 返回该对象的哈希码 `Double`。
`static int`	`hashCode(double value)` 返回一个 `double`值的哈希代码兼容 `Double.hashCode()`。
`int`	`intValue()` 作为一个窄化转换后， `int`返回该 `Double`价值。
`static boolean`	`isFinite(double d)` 返回 `true`如果参数是一个有限的浮点值；否则返回 `false`（楠和无限的争论）。
`boolean`	`isInfinite()` 返回 `true`如果这 `Double`值的幅度无限大， `false`否则。
`static boolean`	`isInfinite(double v)` 返回 `true`如果指定的数量级为无穷大，否则 `false`。
`boolean`	`isNaN()` 如果这 `Double` `true`返回值是一个非数字（NaN）， `false`否则。
`static boolean`	`isNaN(double v)` 返回 `true`如果指定的数量是非数字（NaN）值， `false`否则。
`static double`	`longBitsToDouble(long bits)` 返回对应于给定的点表示的 `double`价值。
`long`	`longValue()` 作为一个窄化转换后 `long`返回该 `Double`价值。
`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`。
`short`	`shortValue()` 作为一个窄化转换后 `short`返回该 `Double`价值。
`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`对象持有 `double`值由参数字符串 `s`代表。

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

Field Detail
- 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.longBitsToDouble(0xfff0000000000000L)。
  
  另请参见：
  
  Constant Field Values
- NaN
```
public static final double NaN
```
  恒持非数字（NaN） double型价值。它相当于返回的值 Double.longBitsToDouble(0x7ff8000000000000L)。
  
  另请参见：
  
  Constant Field Values
- MAX_VALUE
```
public static final double MAX_VALUE
```
  恒持正向最大有限值 double型，（2-2 ^{- 52}）·2 ^{一千零二十三}。它等于十六进制浮点字面 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)。
  
  从以下版本开始：
  
  一点六
  
  另请参见：
  
  Constant Field Values
- MIN_VALUE
```
public static final double MIN_VALUE
```
  恒持正的最小非零的值的类型 double，2 ^{- 1074}。它等于十六进制浮点字面 0x0.0000000000001P-1022也等于 Double.longBitsToDouble(0x1L)。
  
  另请参见：
  
  Constant Field Values
- MAX_EXPONENT
```
public static final int MAX_EXPONENT
```
  最大指数有限 double变可能。它等于返回的值 Math.getExponent(Double.MAX_VALUE)。
  
  从以下版本开始：
  
  一点六
  
  另请参见：
  
  Constant Field Values
- MIN_EXPONENT
```
public static final int MIN_EXPONENT
```
  最低指数归一化 double变可能。它等于返回的值 Math.getExponent(Double.MIN_NORMAL)。
  
  从以下版本开始：
  
  一点六
  
  另请参见：
  
  Constant Field Values
- SIZE
```
public static final int SIZE
```
  用来表示一个 double值的比特数。
  
  从以下版本开始：
  
  一点五
  
  另请参见：
  
  Constant Field Values
- BYTES
```
public static final int BYTES
```
  用来表示一个 double值的字节数。
  
  从以下版本开始：
  
  一点八
  
  另请参见：
  
  Constant Field Values
- TYPE
```
public static final 类<Double> TYPE
```
  double代表原始类型的 类实例。
  
  从以下版本开始：
  
  JDK1.1

Constructor Detail
- Double
```
public Double(double value)
```
  构建了一个新分配的 Double表示原始 double论点。
  
  参数
  
  value -被 Double所代表的值。
- Double
```
public Double(String s)
       throws NumberFormatException
```
  构建了一个新分配的 Double表示式 double字符串表示的浮点值。字符串转换为一个 double价值似乎被 valueOf方法。
  
  参数
  
  s -一个字符串转换为一个 Double。
  
  异常
  
  NumberFormatException如果字符串不包含parsable数。
  
  另请参见：
  
  valueOf(java.lang.String)

方法详细信息

toString
```
public static String toString(double d)
```
返回的字符串表示形式 double论点。下面提到的所有字符都是ASCII字符。
- 如果参数是南，结果是字符串“NaN”。
- 否则，结果是一个字符串，表示该参数的符号和大小（绝对值）。如果符号是负的，结果的第一个字符是“-”（'\u002D'）；如果征阳性，结果中不会出现符号字符。至于大小nullm：
  - 如果nullm是无限的，它是由人物的"Infinity"表示；因此，正无穷大产生的结果"Infinity"和负无穷大产生的结果"-Infinity"。
  - 如果nullm是零，它是由人物的"0.0"表示；因此，负零产生的结果"-0.0"和正零产生的结果"0.0"。
  - 如果nullm大于或等于10^{- 3}但小于10^七，则表现为nullm整数部分，小数形式没有前导零，其次是“.”（'\u002E'），后跟一个或多个十进制数字的小数部分表示nullm。
  - 如果10^{- 3} nullm小于或大于或等于10^七，然后在所谓的“计算机科学记数法表示。“让nulln是唯一的整数，10^nulln≤nullm < 10^{nulln + 1}；然后让空一是nullm和10^nulln数学精确的商，1≤空一＜10。震级是表示空一整数部分，作为一个单一的十进制数字，其次是“.”（'\u002E'），其次是十进制数字占空一小数部分，其次是字母“E”（'\u0045'），其次是nulln表示为十进制整数，如Integer.toString(int)制作方法。
多少位数必须打印为nullm或空一小数部分？必须有至少一个数字来表示小数部分，除此之外很多，但只有一样多，需要独特的区分参数值的类型 double相邻值为更多位数。那就是，假设nullx由该方法产生的有限个非零参数nulld小数表示的精确数学的价值。然后nulld必须就近nullx的 double值；如果两 double值均接近nullx，然后nulld必须成为他们中的一个最重要的点的nulld尾数必须 0。
创建本地化的字符串表示的浮点值，使用子类的NumberFormat。
参数

d - double要转换。

结果

参数的字符串表示形式。

toHexString

public static String toHexString(double d)

返回的 double争论一个十六进制字符串表示形式。下面提到的所有字符都是ASCII字符。

如果参数是南，结果是字符串“NaN”。
否则，结果是一个字符串，表示该参数的符号和大小。如果符号是负的，结果的第一个字符是“-”（'\u002D'）；如果征阳性，结果中不会出现符号字符。至于大小nullm：
- 如果nullm是无限的，它是由字符串"Infinity"表示；因此，正无穷大产生的结果"Infinity"和负无穷大产生的结果"-Infinity"。
- 如果nullm是零，它是由字符串"0x0.0p0"表示；因此，负零产生的结果"-0x0.0p0"和正零产生的结果"0x0.0p0"。
- 如果nullm是一个归一化表示double值，子串来表示尾数和指数等。有效数字的字符表示"0x1."后面跟随一个小写的十六进制表示的其余部分有效。在十六进制表示除非尾随零是所有数字是零删除，在这种情况下，一个单一的零使用。下一步，该指数是由"p"后跟一个十进制数串的偏指数如电话产生Integer.toString对指数值。
- 如果nullm与正规表示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要转换。
结果: 参数的十六进制字符串表示形式。
从以下版本开始：: 一点五

valueOf
```
public static Double valueOf(String s)
                      throws NumberFormatException
```
返回一个 Double对象持有 double值由参数字符串 s代表。
如果s是null，然后NullPointerException抛出。

s领导和尾随空格字符被忽略。空格删除如果由String.trim()方法；即ASCII控制字符的空间和删除。其余的s应该构成nullfloatvalue的词法语法规则描述：

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

在空标志，nullfloatingpointliteral，nullhexnumeral，nullhexdigits，nullsignedinteger和nullfloattypesuffix是在 The Java™ Language Specification词汇结构部分的定义，除了强调不接受之间的数字。如果 s没有一nullfloatvalue形式，然后 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); // Will not throw NumberFormatException
  else {
      // Perform suitable alternative action
  }
 
```
参数

s -被解析的字符串。

结果

一个 Double对象持有价值为代表的 String论点。

异常

NumberFormatException如果字符串不包含parsable数。

valueOf
```
public static Double valueOf(double d)
```
返回表示指定的 double价值 Double实例。如果一个新的 Double实例是不需要的，这种方法一般应优先使用构造函数 Double(double)，这种方法可能会产生显着更好的空间和时间，通过缓存经常请求的价值表现。

参数

d -双重价值。

结果

一个代表 d Double实例。

从以下版本开始：

一点五

parseDouble
```
public static double parseDouble(String s)
                          throws NumberFormatException
```
返回一个新的 double初始化为指定的 String所代表的值，通过类的方法进行 Double valueOf。

参数

s -被解析的字符串。

结果

以字符串表示的 double价值。

异常

NullPointerException -如果字符串是空的

NumberFormatException如果字符串不包含parsable double。

从以下版本开始：

一点二

另请参见：

valueOf(String)

isNaN
```
public static boolean isNaN(double v)
```
返回 true如果指定的数量是非数字（NaN）值， false否则。

参数

v -被测值。

结果

true如果参数的值 false否则南。

isInfinite
```
public static boolean isInfinite(double v)
```
返回 true如果指定的数量级为无穷大，否则 false。

参数

v -被测值。

结果

true如果参数的值为正无穷大和负无穷大； false否则。

isFinite
```
public static boolean isFinite(double d)
```
返回 true如果参数是一个有限的浮点值；否则返回 false（楠和无限的争论）。

参数

d -被测 double价值

结果

true如果参数是一个有限的浮点值， false否则。

从以下版本开始：

一点八

isNaN
```
public boolean isNaN()
```
如果这 Double true返回值是一个非数字（NaN）， false否则。

结果

true如果该对象表示的值 false否则南。

isInfinite
```
public boolean isInfinite()
```
返回 true如果这 Double值的幅度无限大， false否则。

结果

true如果该对象表示的值为正无穷大和负无穷大； false否则。

toString
```
public String toString()
```
返回该对象的字符串表示 Double。该对象表示的原始 double值转换为字符串完全一样，如果一个参数的方法 toString。

重写：

toString 方法重写，继承类 Object

结果

该对象的一个 String表示。

另请参见：

toString(double)

byteValue
```
public byte byteValue()
```
作为一个窄化转换后 byte返回该 Double价值。

重写：

byteValue 方法重写，继承类 Number

结果

的 double的值对象转换为类型 byte代表

从以下版本开始：

JDK1.1

See The Java™ Language Specification:

5.1.3缩小原始转换

shortValue
```
public short shortValue()
```
作为一个窄化转换后 short返回该 Double价值。

重写：

shortValue 方法重写，继承类 Number

结果

通过该对象转换为类型 short代表 double价值

从以下版本开始：

JDK1.1

See The Java™ Language Specification:

5.1.3缩小原始转换

intValue
```
public int intValue()
```
作为一个窄化转换后， int返回该 Double价值。

Specified by:

intValue 方法重写，继承类 Number

结果

通过该对象转换为类型 int代表 double价值

See The Java™ Language Specification:

5.1.3缩小原始转换

longValue
```
public long longValue()
```
作为一个窄化转换后 long返回该 Double价值。

Specified by:

longValue 方法重写，继承类 Number

结果

通过该对象转换为类型 long代表 double价值

See The Java™ Language Specification:

5.1.3缩小原始转换

floatValue
```
public float floatValue()
```
作为一个窄化转换后 float返回该 Double价值。

Specified by:

floatValue 方法重写，继承类 Number

结果

通过该对象转换为类型 float代表 double价值

从以下版本开始：

JDK1.0

See The Java™ Language Specification:

5.1.3缩小原始转换

doubleValue
```
public double doubleValue()
```
返回该对象的 double价值 Double。

Specified by:

doubleValue 方法重写，继承类 Number

结果

该对象表示的 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值的哈希码值。

从以下版本开始：

一点八

equals
```
public boolean equals(Object obj)
```
将此对象与指定的对象进行比较。其结果是 true如果只有参数不 null是 Double对象代表一个 double已为该对象表示的 double相同的值。为了这个目的，两 double值被认为是相同的当且仅当方法返回相同的值 doubleToLongBits(double) long适用于各。
请注意，在大多数情况下，对于类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。

如果参数是南，结果是0x7ff8000000000000L。

在所有的情况下，其结果是一个long整数，当给longBitsToDouble(long)方法，将产生一个浮点值作为参数doubleToLongBits相同（除南值折叠到一个单一的“典范”南值）。

参数

value - double精度浮点数。

结果

表示浮点数的位。

doubleToRawLongBits
```
public static long doubleToRawLongBits(double value)
```
返回根据IEEE 754浮点双格式”位布局表示指定的浮点值，保留非数字（NaN）值。
63位（比特是由面具0x8000000000000000L选定）表示浮点数的牌。位62-52（是由面具0x7ff0000000000000L选位）代表指数。位51-0（是由面具0x000fffffffffffffL选位）代表有效数字（有时称为尾数）的浮点数。

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

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

如果参数是南，结果是代表实际的NaN值的long整数。不像doubleToLongBits方法，doubleToRawLongBits不崩溃的所有比特编码一南一个“规范”的南值。

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

参数

value - double精度浮点数。

结果

表示浮点数的位。

从以下版本开始：

一点三

longBitsToDouble
```
public static double longBitsToDouble(long bits)
```
返回对应于给定的点表示的 double价值。参数是根据IEEE 754浮点双格式”位布局表示浮点值。
如果参数是0x7ff0000000000000L，结果是正无穷大。

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

如果参数是任意值的范围0x7ff0000000000001L通过0x7fffffffffffffffL或范围中的0xfff0000000000001L通过0xffffffffffffffffL，结果是一个南。没有IEEE 754浮点运算提供的java可以区分不同的位模式相同类型的两个NaN值之间。南截然不同的价值只是利用Double.doubleToRawLongBits方法的区别。

在所有其他情况下，让空，努尔，和nullm三值可以从参数计算：
```
 int s = ((bits >> 63) == 0) ? 1 : -1;
 int e = (int)((bits >> 52) & 0x7ffL);
 long m = (e == 0) ?
                 (bits & 0xfffffffffffffL) << 1 :
                 (bits & 0xfffffffffffffL) | 0x10000000000000L;
 
```
然后浮点结果等于零的数学表达·nullm·2 ^nulle-1075价值。
请注意，此方法可能无法返回double南具有完全相同的位模式的long论点。IEEE 754的两种NaN的区分，安静和空信号南nan。两种南之间的差异通常不可见的java。在信号NaN运算转为安静的专辑有不同，但往往相似，位模式。然而，在一些处理器上，仅仅复制一个信令南也执行该转换。特别是，复制一个信令南返回它的调用方法可以执行这种转换。所以longBitsToDouble可能无法返回double与信令南位模式。因此，对于一些long值，doubleToRawLongBits(longBitsToDouble(start))可能空不平等start。此外，这些特定的位模式表示信号NaN是依赖于平台；尽管南位模式，安静或信号，必须在上述南范围。
参数

bits任何 long整数。

结果

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

compareTo
```
public int compareTo(Double anotherDouble)
```
比较两 Double对象数值。有两种方法进行比较，通过这种方法不同于那些由java语言进行数值比较运算符（ <, <=, ==, >=, >）应用原始 double值：
- Double.NaN是通过这种方法被认为是等于和大于所有其他double值（包括Double.POSITIVE_INFINITY）。
- 0.0d是通过这种方法被认为是大于-0.0d。
这保证 Double对象实行这一方法的空自然排序是空符合等于。
Specified by:

compareTo 接口 Comparable<Double>

参数

anotherDouble - Double进行比较。

结果

价值 0如果 anotherDouble数值上等于这 Double；值小于 0如果这 Double数值小于 anotherDouble；和一个值大于 0如果这 Double数值大于 anotherDouble。

从以下版本开始：

一点二

compare
```
public static int compare(double d1,
                          double d2)
```
比较两个指定的 double值。返回的整型值的符号是整数，可以通过调用返回相同的：
```
新的双（D1）。CompareTo（新双（D2））
```
参数

d1 -比较第一 double

d2 -比较二 double

结果

价值 0如果 d1数值等于 d2；值小于 0如果 d1数值小于 d2；和一个值大于 0如果 d1数值大于 d2。

从以下版本开始：

一点四

sum
```
public static double sum(double a,
                         double b)
```
增加了两 double值按运算符。

参数

a -第一个操作数

b -第二个操作数

结果

a和 b的总和

从以下版本开始：

一点八

另请参见：

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大

从以下版本开始：

一点八

另请参见：

BinaryOperator

min
```
public static double min(double a,
                         double b)
```
返回小两 double值如果通过调用 Math.min。

参数

a -第一个操作数

b -第二个操作数

结果

对 a和 b较小。

从以下版本开始：

一点八

另请参见：

BinaryOperator

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Double

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Field Detail

POSITIVE_INFINITY

NEGATIVE_INFINITY

NaN

MAX_VALUE

MIN_NORMAL

MIN_VALUE

MAX_EXPONENT

MIN_EXPONENT

SIZE

BYTES

TYPE

Constructor Detail

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