public final class Double extends Object
double
in an object. An object of type
Double
contains a single field whose type is
double
.
In addition, this class provides several methods for converting a
double
to a String
and a
String
to a double
, as well as other
constants and methods useful when dealing with a
double
.
Modifier and Type  Field and Description 

static double 
MAX_VALUE
The largest positive finite value of type
double . 
static double 
MIN_VALUE
The smallest positive value of type
double . 
static double 
NaN
A NotaNumber (NaN) value of type
double . 
static double 
NEGATIVE_INFINITY
The negative infinity of type
double . 
static double 
POSITIVE_INFINITY
The positive infinity of type
double . 
Constructor and Description 

Double(double value)
Constructs a newly allocated
Double object that
represents the primitive double argument. 
Modifier and Type  Method and Description 

byte 
byteValue()
Returns the value of this Double as a byte (by casting to a byte).

static long 
doubleToLongBits(double value)
Returns a representation of the specified floatingpoint value
according to the IEEE 754 floatingpoint "double
format" bit layout.

double 
doubleValue()
Returns the double value of this Double.

boolean 
equals(Object obj)
Compares this object against the specified object.

float 
floatValue()
Returns the float value of this Double.

int 
hashCode()
Returns a hashcode for this
Double object. 
int 
intValue()
Returns the integer value of this Double (by casting to an int).

boolean 
isInfinite()
Returns true if this Double value is infinitely large in magnitude.

static boolean 
isInfinite(double v)
Returns true if the specified number is infinitely large in magnitude.

boolean 
isNaN()
Returns true if this Double value is the special NotaNumber (NaN)
value.

static boolean 
isNaN(double v)
Returns true if the specified number is the special NotaNumber (NaN)
value.

static double 
longBitsToDouble(long bits)
Returns the doublefloat corresponding to a given bit representation.

long 
longValue()
Returns the long value of this Double (by casting to a long).

static double 
parseDouble(String s)
Returns a new double initialized to the value represented by the
specified
String , as performed by the valueOf
method of class Double . 
short 
shortValue()
Returns the value of this Double as a short (by casting to a short).

String 
toString()
Returns a String representation of this Double object.

static String 
toString(double d)
Creates a string representation of the
double
argument. 
static Double 
valueOf(String s)
Returns a new
Double object initialized to the value
represented by the specified string. 
public static final double POSITIVE_INFINITY
double
.
It is equal to the value returned by
Double.longBitsToDouble(0x7ff0000000000000L)
.public static final double NEGATIVE_INFINITY
double
.
It is equal to the value returned by
Double.longBitsToDouble(0xfff0000000000000L)
.public static final double NaN
double
.
It is equal to the value returned by
Double.longBitsToDouble(0x7ff8000000000000L)
.public static final double MAX_VALUE
double
.
It is equal to the value returned by
Double.longBitsToDouble(0x7fefffffffffffffL)
public static final double MIN_VALUE
double
.
It is equal to the value returned by
Double.longBitsToDouble(0x1L)
.public Double(double value)
Double
object that
represents the primitive double
argument.value
 the value to be represented by the Double
.public static String toString(double d)
double
argument. All characters mentioned below are ASCII characters.

'
('
'); if the sign is positive, no sign character
appears in the result. As for the magnitude m:
"Infinity"
; thus, positive infinity produces the result
"Infinity"
and negative infinity produces the result
"Infinity"
.
"0.0"
; thus, negative zero produces the result
"0.0"
and positive zero produces the result
"0.0"
.
'.'
(.
), followed by one or more decimal
digits representing the fractional part of m.
'.'
(.
), followed by decimal digits
representing the fractional part of a, followed by the letter
'E'
(E
), followed by a representation
of n as a decimal integer, as produced by the method
Integer.toString(int)
.
How many digits must be printed for the fractional part of
m or a? There must be at least one digit to represent
the fractional part, and beyond that as many, but only as many, more
digits as are needed to uniquely distinguish the argument value from
adjacent values of type 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 the double
value nearest
to x; or if two double
values are equally close
to x, then d must be one of them and the least
significant bit of the significand of d must be 0
.
d
 the double
to be converted.public static Double valueOf(String s) throws NumberFormatException
Double
object initialized to the value
represented by the specified string. The string s
is
interpreted as the representation of a floatingpoint value and a
Double
object representing that value is created and
returned.
If s
is null
, then a
NullPointerException
is thrown.
Leading and trailing whitespace characters in s are ignored. The rest
of s
should constitute a FloatValue as described
by the lexical rule:
where Sign and FloatingPointLiteral are as defined in Section 3.10.2 of the Java Language Specification. If it does not have the form of a FloatValue, then aFloatValue: Sign_{opt} FloatingPointLiteral
NumberFormatException
is
thrown. Otherwise, it is regarded as representing an exact decimal
value in the usual "computerized scientific notation"; this exact
decimal value is then conceptually converted to an "infinitely
precise" binary value that is then rounded to type double
by the usual roundtonearest rule of IEEE 754 floatingpoint
arithmetic. Finally, a new object of class Double
is
created to represent the double
value.s
 the string to be parsed.Double
initialized to the
value represented by the string argument.NumberFormatException
 if the string does not contain a
parsable number.public static double parseDouble(String s) throws NumberFormatException
String
, as performed by the valueOf
method of class Double
.s
 the string to be parsed.NumberFormatException
 if the string does not contain a
parsable double.valueOf(String)
public static boolean isNaN(double v)
v
 the value to be tested.true
if the value of the argument is NaN;
false
otherwise.public static boolean isInfinite(double v)
v
 the value to be tested.true
if the value of the argument is positive
infinity or negative infinity; false
otherwise.public boolean isNaN()
true
if the value represented by this object is
NaN; false
otherwise.public boolean isInfinite()
true
if the value represented by this object is
positive infinity or negative infinity;
false
otherwise.public String toString()
double
value represented by this
object is converted to a string exactly as if by the method
toString
of one argument.toString
in class Object
String
representation of this object.toString(double)
public byte byteValue()
public short shortValue()
public int intValue()
double
value represented by this object is
converted to type int
and the result of the
conversion is returned.public long longValue()
double
value represented by this object is
converted to type long
and the result of the
conversion is returned.public float floatValue()
double
value represented by this object is
converted to type float
and the result of the
conversion is returned.public double doubleValue()
double
value represented by this object.public int hashCode()
Double
object. The result
is the exclusive OR of the two halves of the long integer bit
representation, exactly as produced by the method
doubleToLongBits(double)
, of the primitive
double
value represented by this Double
object. That is, the hashcode is the value of the expression:
where(int)(v^(v>>>32))
v
is defined by:
long v = Double.doubleToLongBits(this.doubleValue());
hashCode
in class Object
hash code
value for this object.Object.equals(java.lang.Object)
,
Hashtable
public boolean equals(Object obj)
true
if and only if the argument is
not null
and is a Double
object that
represents a double that has the identical bit pattern to the bit
pattern of the double represented by this object. For this purpose,
two double
values are considered to be the same if and
only if the method doubleToLongBits(double)
returns the same
long value when applied to each.
Note that in most cases, for two instances of class
Double
, d1
and d2
, the
value of d1.equals(d2)
is true
if and
only if
d1.doubleValue() == d2.doubleValue()
also has the value true
. However, there are two
exceptions:
d1
and d2
both represent
Double.NaN
, then the equals
method
returns true
, even though
Double.NaN==Double.NaN
has the value
false
.
d1
represents +0.0
while
d2
represents 0.0
, or vice versa,
the equals
test has the value false
,
even though +0.0==0.0
has the value true
.
This allows hashtables to operate properly.
equals
in class Object
obj
 the object to compare with.true
if the objects are the same;
false
otherwise.Boolean.hashCode()
,
Hashtable
public static long doubleToLongBits(double value)
Bit 63 (the bit that is selected by the mask
0x8000000000000000L
) represents the sign of the
floatingpoint number. Bits
6252 (the bits that are selected by the mask
0x7ff0000000000000L
) represent the exponent. Bits 510
(the bits that are selected by the mask
0x000fffffffffffffL
) represent the significand
(sometimes called the mantissa) of the floatingpoint 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 long
integer that, when
given to the longBitsToDouble(long)
method, will produce a
floatingpoint value equal to the argument to
doubleToLongBits
.
value
 a double precision floatingpoint number.public static double longBitsToDouble(long bits)
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
0x7ff0000000000001L
through
0x7fffffffffffffffL
or in the range
0xfff0000000000001L
through
0xffffffffffffffffL
, the result is NaN. All IEEE 754
NaN values of type double
are, in effect, lumped together
by the Java programming language into a single value called NaN.
In all other cases, let s, e, and m be three values that can be computed from the argument:
Then the floatingpoint result equals the value of the mathematical expression s·m·2^{e1075}.int s = ((bits >> 63) == 0) ? 1 : 1; int e = (int)((bits >> 52) & 0x7ffL); long m = (e == 0) ? (bits & 0xfffffffffffffL) << 1 : (bits & 0xfffffffffffffL)  0x10000000000000L;
bits
 any long
integer.double
floatingpoint value with the same
bit pattern.Copyright © 2013, Oracle and/or its affiliates. All rights reserved.
Use is subject to License Terms. Your use of this web site or any of its contents or software indicates your agreement to be bound by these License Terms.