- java.lang.Object
- 
- java.lang.Number
- 
- java.lang.Double
 
 
- 
- All Implemented Interfaces:
- Serializable,- Comparable<Double>
 
 public final class Double extends Number implements Comparable<Double> TheDoubleclass wraps a value of the primitive typedoublein an object. An object of typeDoublecontains a single field whose type isdouble.In addition, this class provides several methods for converting a doubleto aStringand aStringto adouble, as well as other constants and methods useful when dealing with adouble.- Since:
- 1.0
- See Also:
- Serialized Form
 
- 
- 
Field SummaryFields Modifier and Type Field Description static intBYTESThe number of bytes used to represent adoublevalue.static intMAX_EXPONENTMaximum exponent a finitedoublevariable may have.static doubleMAX_VALUEA constant holding the largest positive finite value of typedouble, (2-2-52)·21023.static intMIN_EXPONENTMinimum exponent a normalizeddoublevariable may have.static doubleMIN_NORMALA constant holding the smallest positive normal value of typedouble, 2-1022.static doubleMIN_VALUEA constant holding the smallest positive nonzero value of typedouble, 2-1074.static doubleNaNA constant holding a Not-a-Number (NaN) value of typedouble.static doubleNEGATIVE_INFINITYA constant holding the negative infinity of typedouble.static doublePOSITIVE_INFINITYA constant holding the positive infinity of typedouble.static intSIZEThe number of bits used to represent adoublevalue.static Class<Double>TYPETheClassinstance representing the primitive typedouble.
 - 
Method SummaryAll Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description bytebyteValue()Returns the value of thisDoubleas abyteafter a narrowing primitive conversion.static intcompare(double d1, double d2)Compares the two specifieddoublevalues.intcompareTo(Double anotherDouble)Compares twoDoubleobjects numerically.static longdoubleToLongBits(double value)Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout.static longdoubleToRawLongBits(double value)Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout, preserving Not-a-Number (NaN) values.doubledoubleValue()Returns thedoublevalue of thisDoubleobject.booleanequals(Object obj)Compares this object against the specified object.floatfloatValue()Returns the value of thisDoubleas afloatafter a narrowing primitive conversion.inthashCode()Returns a hash code for thisDoubleobject.static inthashCode(double value)Returns a hash code for adoublevalue; compatible withDouble.hashCode().intintValue()Returns the value of thisDoubleas anintafter a narrowing primitive conversion.static booleanisFinite(double d)Returnstrueif the argument is a finite floating-point value; returnsfalseotherwise (for NaN and infinity arguments).booleanisInfinite()Returnstrueif thisDoublevalue is infinitely large in magnitude,falseotherwise.static booleanisInfinite(double v)Returnstrueif the specified number is infinitely large in magnitude,falseotherwise.booleanisNaN()Returnstrueif thisDoublevalue is a Not-a-Number (NaN),falseotherwise.static booleanisNaN(double v)Returnstrueif the specified number is a Not-a-Number (NaN) value,falseotherwise.static doublelongBitsToDouble(long bits)Returns thedoublevalue corresponding to a given bit representation.longlongValue()Returns the value of thisDoubleas alongafter a narrowing primitive conversion.static doublemax(double a, double b)Returns the greater of twodoublevalues as if by callingMath.max.static doublemin(double a, double b)Returns the smaller of twodoublevalues as if by callingMath.min.static doubleparseDouble(String s)Returns a newdoubleinitialized to the value represented by the specifiedString, as performed by thevalueOfmethod of classDouble.shortshortValue()Returns the value of thisDoubleas ashortafter a narrowing primitive conversion.static doublesum(double a, double b)Adds twodoublevalues together as per the + operator.static StringtoHexString(double d)Returns a hexadecimal string representation of thedoubleargument.StringtoString()Returns a string representation of thisDoubleobject.static StringtoString(double d)Returns a string representation of thedoubleargument.static DoublevalueOf(double d)Returns aDoubleinstance representing the specifieddoublevalue.static DoublevalueOf(String s)Returns aDoubleobject holding thedoublevalue represented by the argument strings.
 
- 
- 
- 
Field Detail- 
POSITIVE_INFINITYpublic static final double POSITIVE_INFINITY A constant holding the positive infinity of typedouble. It is equal to the value returned byDouble.longBitsToDouble(0x7ff0000000000000L).- See Also:
- Constant Field Values
 
 - 
NEGATIVE_INFINITYpublic static final double NEGATIVE_INFINITY A constant holding the negative infinity of typedouble. It is equal to the value returned byDouble.longBitsToDouble(0xfff0000000000000L).- See Also:
- Constant Field Values
 
 - 
NaNpublic static final double NaN A constant holding a Not-a-Number (NaN) value of typedouble. It is equivalent to the value returned byDouble.longBitsToDouble(0x7ff8000000000000L).- See Also:
- Constant Field Values
 
 - 
MAX_VALUEpublic static final double MAX_VALUE A constant holding the largest positive finite value of typedouble, (2-2-52)·21023. It is equal to the hexadecimal floating-point literal0x1.fffffffffffffP+1023and also equal toDouble.longBitsToDouble(0x7fefffffffffffffL).- See Also:
- Constant Field Values
 
 - 
MIN_NORMALpublic static final double MIN_NORMAL A constant holding the smallest positive normal value of typedouble, 2-1022. It is equal to the hexadecimal floating-point literal0x1.0p-1022and also equal toDouble.longBitsToDouble(0x0010000000000000L).- Since:
- 1.6
- See Also:
- Constant Field Values
 
 - 
MIN_VALUEpublic static final double MIN_VALUE A constant holding the smallest positive nonzero value of typedouble, 2-1074. It is equal to the hexadecimal floating-point literal0x0.0000000000001P-1022and also equal toDouble.longBitsToDouble(0x1L).- See Also:
- Constant Field Values
 
 - 
MAX_EXPONENTpublic static final int MAX_EXPONENT Maximum exponent a finitedoublevariable may have. It is equal to the value returned byMath.getExponent(Double.MAX_VALUE).- Since:
- 1.6
- See Also:
- Constant Field Values
 
 - 
MIN_EXPONENTpublic static final int MIN_EXPONENT Minimum exponent a normalizeddoublevariable may have. It is equal to the value returned byMath.getExponent(Double.MIN_NORMAL).- Since:
- 1.6
- See Also:
- Constant Field Values
 
 - 
SIZEpublic static final int SIZE The number of bits used to represent adoublevalue.- Since:
- 1.5
- See Also:
- Constant Field Values
 
 - 
BYTESpublic static final int BYTES The number of bytes used to represent adoublevalue.- Since:
- 1.8
- See Also:
- Constant Field Values
 
 
- 
 - 
Constructor Detail- 
Double@Deprecated(since="9") public Double(double value) Deprecated.It is rarely appropriate to use this constructor. The static factoryvalueOf(double)is generally a better choice, as it is likely to yield significantly better space and time performance.Constructs a newly allocatedDoubleobject that represents the primitivedoubleargument.- Parameters:
- value- the value to be represented by the- Double.
 
 - 
Double@Deprecated(since="9") public Double(String s) throws NumberFormatException Deprecated.It is rarely appropriate to use this constructor. UseparseDouble(String)to convert a string to adoubleprimitive, or usevalueOf(String)to convert a string to aDoubleobject.Constructs a newly allocatedDoubleobject that represents the floating-point value of typedoublerepresented by the string. The string is converted to adoublevalue as if by thevalueOfmethod.- Parameters:
- s- a string to be converted to a- Double.
- Throws:
- NumberFormatException- if the string does not contain a parsable number.
 
 
- 
 - 
Method Detail- 
toStringpublic static String toString(double d) Returns a string representation of thedoubleargument. All characters mentioned below are ASCII characters.- If the argument is NaN, the result is the string
     "NaN".
- Otherwise, the result is a string that represents the sign and
 magnitude (absolute value) of the argument. If the sign is negative,
 the first character of the result is '-' ('\u002D'); if the sign is positive, no sign character appears in the result. As for the magnitude m:- If m is infinity, it is represented by the characters
 "Infinity"; thus, positive infinity produces the result"Infinity"and negative infinity produces the result"-Infinity".
- If m is zero, it is represented by the characters
 "0.0"; thus, negative zero produces the result"-0.0"and positive zero produces the result"0.0".
- If m is greater than or equal to 10-3 but less
 than 107, then it is represented as the integer part of
 m, in decimal form with no leading zeroes, followed by
 '.' ('\u002E'), followed by one or more decimal digits representing the fractional part of m.
- If m is less than 10-3 or greater than or
 equal to 107, then it is represented in so-called
 "computerized scientific notation." Let n be the unique
 integer such that 10n ≤ m <
 10n+1; then let a be the
 mathematically exact quotient of m and
 10n so that 1 ≤ a < 10. The
 magnitude is then represented as the integer part of a,
 as a single decimal digit, followed by '.' ('\u002E'), followed by decimal digits representing the fractional part of a, followed by the letter 'E' ('\u0045'), followed by a representation of n as a decimal integer, as produced by the methodInteger.toString(int).
 
- If m is infinity, it is represented by the characters
 
 double. That is, suppose that x is the exact mathematical value represented by the decimal representation produced by this method for a finite nonzero argument d. Then d must be thedoublevalue nearest to x; or if twodoublevalues are equally close to x, then d must be one of them and the least significant bit of the significand of d must be0.To create localized string representations of a floating-point value, use subclasses of NumberFormat.- Parameters:
- d- the- doubleto be converted.
- Returns:
- a string representation of the argument.
 
- If the argument is NaN, the result is the string
     "
 - 
toHexStringpublic static String toHexString(double d) Returns a hexadecimal string representation of thedoubleargument. All characters mentioned below are ASCII characters.- If the argument is NaN, the result is the string
     "NaN".
- Otherwise, the result is a string that represents the sign
 and magnitude of the argument. If the sign is negative, the
 first character of the result is '-' ('\u002D'); if the sign is positive, no sign character appears in the result. As for the magnitude m:- If m is infinity, it is represented by the string
 "Infinity"; thus, positive infinity produces the result"Infinity"and negative infinity produces the result"-Infinity".
- If m is zero, it is represented by the string
 "0x0.0p0"; thus, negative zero produces the result"-0x0.0p0"and positive zero produces the result"0x0.0p0".
- If m is a doublevalue with a normalized representation, substrings are used to represent the significand and exponent fields. The significand is represented by the characters"0x1."followed by a lowercase hexadecimal representation of the rest of the significand as a fraction. Trailing zeros in the hexadecimal representation are removed unless all the digits are zero, in which case a single zero is used. Next, the exponent is represented by"p"followed by a decimal string of the unbiased exponent as if produced by a call toInteger.toStringon the exponent value.
- If m is a doublevalue with a subnormal representation, the significand is represented by the characters"0x0."followed by a hexadecimal representation of the rest of the significand as a fraction. Trailing zeros in the hexadecimal representation are removed. Next, the exponent is represented by"p-1022". Note that there must be at least one nonzero digit in a subnormal significand.
 
- If m is infinity, it is represented by the string
 
 Examples Floating-point Value Hexadecimal String 1.00x1.0p0-1.0-0x1.0p02.00x1.0p13.00x1.8p10.50x1.0p-10.250x1.0p-2Double.MAX_VALUE0x1.fffffffffffffp1023Minimum Normal Value0x1.0p-1022Maximum Subnormal Value0x0.fffffffffffffp-1022Double.MIN_VALUE0x0.0000000000001p-1022- Parameters:
- d- the- doubleto be converted.
- Returns:
- a hex string representation of the argument.
- Since:
- 1.5
 
- If the argument is NaN, the result is the string
     "
 - 
valueOfpublic static Double valueOf(String s) throws NumberFormatException Returns aDoubleobject holding thedoublevalue represented by the argument strings.If sisnull, then aNullPointerExceptionis thrown.Leading and trailing whitespace characters in sare ignored. Whitespace is removed as if by theString.trim()method; that is, both ASCII space and control characters are removed. The rest ofsshould constitute a FloatValue as described by the lexical syntax rules:
 where Sign, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger and FloatTypeSuffix are as defined in the lexical structure sections of The Java™ Language Specification, except that underscores are not accepted between digits. If- FloatValue:
- Signopt NaN
- Signopt
Infinity
- Signopt FloatingPointLiteral
- Signopt HexFloatingPointLiteral
- SignedInteger
- Signopt
 - HexFloatingPointLiteral:
- HexSignificand BinaryExponent FloatTypeSuffixopt
 - HexSignificand:
- HexNumeral
 - HexNumeral
.0xHexDigitsopt.HexDigits0XHexDigitsopt.HexDigits
- HexNumeral
 - BinaryExponent:
- BinaryExponentIndicator SignedInteger
 - BinaryExponentIndicator:
- p- P
 sdoes not have the form of a FloatValue, then aNumberFormatExceptionis thrown. Otherwise,sis regarded as representing an exact decimal value in the usual "computerized scientific notation" or as an exact hexadecimal value; this exact numerical value is then conceptually converted to an "infinitely precise" binary value that is then rounded to typedoubleby the usual round-to-nearest rule of IEEE 754 floating-point arithmetic, which includes preserving the sign of a zero value. Note that the round-to-nearest rule also implies overflow and underflow behaviour; if the exact value ofsis large enough in magnitude (greater than or equal to (MAX_VALUE+ulp(MAX_VALUE)/2), rounding todoublewill result in an infinity and if the exact value ofsis small enough in magnitude (less than or equal toMIN_VALUE/2), rounding to float will result in a zero. Finally, after rounding aDoubleobject representing thisdoublevalue is returned.To interpret localized string representations of a floating-point value, use subclasses of NumberFormat.Note that trailing format specifiers, specifiers that determine the type of a floating-point literal ( 1.0fis afloatvalue;1.0dis adoublevalue), do not influence the results of this method. In other words, the numerical value of the input string is converted directly to the target floating-point type. The two-step sequence of conversions, string tofloatfollowed byfloattodouble, is not equivalent to converting a string directly todouble. For example, thefloatliteral0.1fis equal to thedoublevalue0.10000000149011612; thefloatliteral0.1frepresents a different numerical value than thedoubleliteral0.1. (The numerical value 0.1 cannot be exactly represented in a binary floating-point number.)To avoid calling this method on an invalid string and having a NumberFormatExceptionbe thrown, the regular expression below can be used to screen the input string: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 }- Parameters:
- s- the string to be parsed.
- Returns:
- a Doubleobject holding the value represented by theStringargument.
- Throws:
- NumberFormatException- if the string does not contain a parsable number.
 
 - 
valueOfpublic static Double valueOf(double d) Returns aDoubleinstance representing the specifieddoublevalue. If a newDoubleinstance is not required, this method should generally be used in preference to the constructorDouble(double), as this method is likely to yield significantly better space and time performance by caching frequently requested values.- Parameters:
- d- a double value.
- Returns:
- a Doubleinstance representingd.
- Since:
- 1.5
 
 - 
parseDoublepublic static double parseDouble(String s) throws NumberFormatException Returns a newdoubleinitialized to the value represented by the specifiedString, as performed by thevalueOfmethod of classDouble.- Parameters:
- s- the string to be parsed.
- Returns:
- the doublevalue represented by the string argument.
- Throws:
- NullPointerException- if the string is null
- NumberFormatException- if the string does not contain a parsable- double.
- Since:
- 1.2
- See Also:
- valueOf(String)
 
 - 
isNaNpublic static boolean isNaN(double v) Returnstrueif the specified number is a Not-a-Number (NaN) value,falseotherwise.- Parameters:
- v- the value to be tested.
- Returns:
- trueif the value of the argument is NaN;- falseotherwise.
 
 - 
isInfinitepublic static boolean isInfinite(double v) Returnstrueif the specified number is infinitely large in magnitude,falseotherwise.- Parameters:
- v- the value to be tested.
- Returns:
- trueif the value of the argument is positive infinity or negative infinity;- falseotherwise.
 
 - 
isFinitepublic static boolean isFinite(double d) Returnstrueif the argument is a finite floating-point value; returnsfalseotherwise (for NaN and infinity arguments).- Parameters:
- d- the- doublevalue to be tested
- Returns:
- trueif the argument is a finite floating-point value,- falseotherwise.
- Since:
- 1.8
 
 - 
isNaNpublic boolean isNaN() Returnstrueif thisDoublevalue is a Not-a-Number (NaN),falseotherwise.- Returns:
- trueif the value represented by this object is NaN;- falseotherwise.
 
 - 
isInfinitepublic boolean isInfinite() Returnstrueif thisDoublevalue is infinitely large in magnitude,falseotherwise.- Returns:
- trueif the value represented by this object is positive infinity or negative infinity;- falseotherwise.
 
 - 
toStringpublic String toString() Returns a string representation of thisDoubleobject. The primitivedoublevalue represented by this object is converted to a string exactly as if by the methodtoStringof one argument.- Overrides:
- toStringin class- Object
- Returns:
- a Stringrepresentation of this object.
- See Also:
- toString(double)
 
 - 
byteValuepublic byte byteValue() Returns the value of thisDoubleas abyteafter a narrowing primitive conversion.
 - 
shortValuepublic short shortValue() Returns the value of thisDoubleas ashortafter a narrowing primitive conversion.- Overrides:
- shortValuein class- Number
- Returns:
- the doublevalue represented by this object converted to typeshort
- Since:
- 1.1
- See The Java™ Language Specification:
- 5.1.3 Narrowing Primitive Conversions
 
 - 
intValuepublic int intValue() Returns the value of thisDoubleas anintafter a narrowing primitive conversion.
 - 
longValuepublic long longValue() Returns the value of thisDoubleas alongafter a narrowing primitive conversion.
 - 
floatValuepublic float floatValue() Returns the value of thisDoubleas afloatafter a narrowing primitive conversion.- Specified by:
- floatValuein class- Number
- Returns:
- the doublevalue represented by this object converted to typefloat
- Since:
- 1.0
- See The Java™ Language Specification:
- 5.1.3 Narrowing Primitive Conversions
 
 - 
doubleValuepublic double doubleValue() Returns thedoublevalue of thisDoubleobject.- Specified by:
- doubleValuein class- Number
- Returns:
- the doublevalue represented by this object
 
 - 
hashCodepublic int hashCode() Returns a hash code for thisDoubleobject. The result is the exclusive OR of the two halves of thelonginteger bit representation, exactly as produced by the methoddoubleToLongBits(double), of the primitivedoublevalue represented by thisDoubleobject. That is, the hash code is the value of the expression:
 where(int)(v^(v>>>32))vis defined by:long v = Double.doubleToLongBits(this.doubleValue());- Overrides:
- hashCodein class- Object
- Returns:
- a hash codevalue for this object.
- See Also:
- Object.equals(java.lang.Object),- System.identityHashCode(java.lang.Object)
 
 - 
hashCodepublic static int hashCode(double value) Returns a hash code for adoublevalue; compatible withDouble.hashCode().- Parameters:
- value- the value to hash
- Returns:
- a hash code value for a doublevalue.
- Since:
- 1.8
 
 - 
equalspublic boolean equals(Object obj) Compares this object against the specified object. The result istrueif and only if the argument is notnulland is aDoubleobject that represents adoublethat has the same value as thedoublerepresented by this object. For this purpose, twodoublevalues are considered to be the same if and only if the methoddoubleToLongBits(double)returns the identicallongvalue when applied to each.Note that in most cases, for two instances of class Double,d1andd2, the value ofd1.equals(d2)istrueif and only ifd1.doubleValue() == d2.doubleValue()also has the value true. However, there are two exceptions:- If d1andd2both representDouble.NaN, then theequalsmethod returnstrue, even thoughDouble.NaN==Double.NaNhas the valuefalse.
- If d1represents+0.0whiled2represents-0.0, or vice versa, theequaltest has the valuefalse, even though+0.0==-0.0has the valuetrue.
 - Overrides:
- equalsin class- Object
- Parameters:
- obj- the object to compare with.
- Returns:
- trueif the objects are the same;- falseotherwise.
- See Also:
- doubleToLongBits(double)
 
- If 
 - 
doubleToLongBitspublic static long doubleToLongBits(double value) Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout.Bit 63 (the bit that is selected by the mask 0x8000000000000000L) represents the sign of the floating-point number. Bits 62-52 (the bits that are selected by the mask0x7ff0000000000000L) represent the exponent. Bits 51-0 (the bits that are selected by the mask0x000fffffffffffffL) represent the significand (sometimes called the mantissa) of the floating-point number.If the argument is positive infinity, the result is 0x7ff0000000000000L.If the argument is negative infinity, the result is 0xfff0000000000000L.If the argument is NaN, the result is 0x7ff8000000000000L.In all cases, the result is a longinteger that, when given to thelongBitsToDouble(long)method, will produce a floating-point value the same as the argument todoubleToLongBits(except all NaN values are collapsed to a single "canonical" NaN value).- Parameters:
- value- a- doubleprecision floating-point number.
- Returns:
- the bits that represent the floating-point number.
 
 - 
doubleToRawLongBitspublic static long doubleToRawLongBits(double value) Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout, preserving Not-a-Number (NaN) values.Bit 63 (the bit that is selected by the mask 0x8000000000000000L) represents the sign of the floating-point number. Bits 62-52 (the bits that are selected by the mask0x7ff0000000000000L) represent the exponent. Bits 51-0 (the bits that are selected by the mask0x000fffffffffffffL) represent the significand (sometimes called the mantissa) of the floating-point number.If the argument is positive infinity, the result is 0x7ff0000000000000L.If the argument is negative infinity, the result is 0xfff0000000000000L.If the argument is NaN, the result is the longinteger representing the actual NaN value. Unlike thedoubleToLongBitsmethod,doubleToRawLongBitsdoes not collapse all the bit patterns encoding a NaN to a single "canonical" NaN value.In all cases, the result is a longinteger that, when given to thelongBitsToDouble(long)method, will produce a floating-point value the same as the argument todoubleToRawLongBits.- Parameters:
- value- a- doubleprecision floating-point number.
- Returns:
- the bits that represent the floating-point number.
- Since:
- 1.3
 
 - 
longBitsToDoublepublic static double longBitsToDouble(long bits) Returns thedoublevalue corresponding to a given bit representation. The argument is considered to be a representation of a floating-point value according to the IEEE 754 floating-point "double format" bit layout.If the argument is 0x7ff0000000000000L, the result is positive infinity.If the argument is 0xfff0000000000000L, the result is negative infinity.If the argument is any value in the range 0x7ff0000000000001Lthrough0x7fffffffffffffffLor in the range0xfff0000000000001Lthrough0xffffffffffffffffL, the result is a NaN. No IEEE 754 floating-point operation provided by Java can distinguish between two NaN values of the same type with different bit patterns. Distinct values of NaN are only distinguishable by use of theDouble.doubleToRawLongBitsmethod.In all other cases, let s, e, and m be three values that can be computed from the argument: 
 Then the floating-point result equals the value of the mathematical expression s·m·2e-1075.int s = ((bits >> 63) == 0) ? 1 : -1; int e = (int)((bits >> 52) & 0x7ffL); long m = (e == 0) ? (bits & 0xfffffffffffffL) << 1 : (bits & 0xfffffffffffffL) | 0x10000000000000L;Note that this method may not be able to return a doubleNaN with exactly same bit pattern as thelongargument. IEEE 754 distinguishes between two kinds of NaNs, quiet NaNs and signaling NaNs. The differences between the two kinds of NaN are generally not visible in Java. Arithmetic operations on signaling NaNs turn them into quiet NaNs with a different, but often similar, bit pattern. However, on some processors merely copying a signaling NaN also performs that conversion. In particular, copying a signaling NaN to return it to the calling method may perform this conversion. SolongBitsToDoublemay not be able to return adoublewith a signaling NaN bit pattern. Consequently, for somelongvalues,doubleToRawLongBits(longBitsToDouble(start))may not equalstart. Moreover, which particular bit patterns represent signaling NaNs is platform dependent; although all NaN bit patterns, quiet or signaling, must be in the NaN range identified above.- Parameters:
- bits- any- longinteger.
- Returns:
- the doublefloating-point value with the same bit pattern.
 
 - 
compareTopublic int compareTo(Double anotherDouble) Compares twoDoubleobjects numerically. There are two ways in which comparisons performed by this method differ from those performed by the Java language numerical comparison operators (<, <=, ==, >=, >) when applied to primitivedoublevalues:- 
          Double.NaNis considered by this method to be equal to itself and greater than all otherdoublevalues (includingDouble.POSITIVE_INFINITY).
- 
          0.0dis considered by this method to be greater than-0.0d.
 Doubleobjects imposed by this method is consistent with equals.- Specified by:
- compareToin interface- Comparable<Double>
- Parameters:
- anotherDouble- the- Doubleto be compared.
- Returns:
- the value 0ifanotherDoubleis numerically equal to thisDouble; a value less than0if thisDoubleis numerically less thananotherDouble; and a value greater than0if thisDoubleis numerically greater thananotherDouble.
- Since:
- 1.2
 
- 
          
 - 
comparepublic static int compare(double d1, double d2)Compares the two specifieddoublevalues. The sign of the integer value returned is the same as that of the integer that would be returned by the call:new Double(d1).compareTo(new Double(d2))- Parameters:
- d1- the first- doubleto compare
- d2- the second- doubleto compare
- Returns:
- the value 0ifd1is numerically equal tod2; a value less than0ifd1is numerically less thand2; and a value greater than0ifd1is numerically greater thand2.
- Since:
- 1.4
 
 - 
sumpublic static double sum(double a, double b)Adds twodoublevalues together as per the + operator.- Parameters:
- a- the first operand
- b- the second operand
- Returns:
- the sum of aandb
- Since:
- 1.8
- See Also:
- BinaryOperator
- See The Java™ Language Specification:
- 4.2.4 Floating-Point Operations
 
 - 
maxpublic static double max(double a, double b)Returns the greater of twodoublevalues as if by callingMath.max.- Parameters:
- a- the first operand
- b- the second operand
- Returns:
- the greater of aandb
- Since:
- 1.8
- See Also:
- BinaryOperator
 
 - 
minpublic static double min(double a, double b)Returns the smaller of twodoublevalues as if by callingMath.min.- Parameters:
- a- the first operand
- b- the second operand
- Returns:
- the smaller of aandb.
- Since:
- 1.8
- See Also:
- BinaryOperator
 
 
- 
 
-