|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectjava.lang.Number
java.lang.Double
public final class Double
The Double
class wraps a value of the primitive type
double
in an object. An object of type
Double
contains a single field whose type is
double
.
Field Summary | |
---|---|
static double |
MAX_VALUE
A constant holding the largest positive finite value of type double , 1·7976931348623157e+308. |
static double |
MIN_VALUE
A constant holding the smallest positive nonzero value of type double , 4.94065645841246544e-324. |
static double |
NaN
A constant holding a Not-a-Number (NaN) value of type double . |
static double |
NEGATIVE_INFINITY
A constant holding the negative infinity of type double . |
static double |
POSITIVE_INFINITY
A constant holding the positive infinity of type double . |
Constructor Summary | |
---|---|
Double(double d)
Constructs a newly allocated Double object that
represents the primitive double argument. |
Method Summary | |
---|---|
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 floating-point value according to the IEEE 754 floating-point "double format" bit layout. |
double |
doubleValue()
Returns the double value of this
Double object. |
boolean |
equals(Object obj)
Compares this object against the specified object. |
float |
floatValue()
Returns the float value of this
Double object. |
int |
hashCode()
Returns a hashcode for this Double object. |
int |
intValue()
Returns the value of this Double as an
int (by casting to type int ). |
boolean |
isInfinite()
Returns true if this Double value is infinitely large in magnitude. |
static boolean |
isInfinite(double d)
Returns true if the specified number is infinitely large in magnitude. |
boolean |
isNaN()
Returns true if this Double value is the special Not-a-Number (NaN) value. |
static boolean |
isNaN(double d)
Returns true if the specified number is the special Not-a-Number (NaN) value. |
static double |
longBitsToDouble(long bits)
Returns the double value corresponding to a given
bit representation. |
long |
longValue()
Returns the value of this Double as a
long (by casting to type 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. |
Methods inherited from class java.lang.Object |
---|
getClass, notify, notifyAll, wait, wait, wait |
Field Detail |
---|
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 equivalent to the value returned by
Double.longBitsToDouble(0x7ff8000000000000L)
.
public static final double MAX_VALUE
double
, 1·7976931348623157e+308. It is equal to the
hexadecimal floating-point literal 0x1.0p-1022
and also
equal to Double.longBitsToDouble(0x0010000000000000L)
.
public static final double MIN_VALUE
double
, 4.94065645841246544e-324. It is equal to the
hexadecimal floating-point literal
0x0.0000000000001P-1022
and also equal to
Double.longBitsToDouble(0x1L)
.
Constructor Detail |
---|
public Double(double d)
Double
object that
represents the primitive double
argument.
d
- the value to be represented by the Double
.Method Detail |
---|
public static long doubleToLongBits(double value)
value
- a double
precision floating-point number.
public static double longBitsToDouble(long bits)
double
value 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.
bits
- any long
integer.
double
floating-point value with the same
bit pattern.public byte byteValue()
Double
as a byte
(by
casting to a byte
).
byteValue
in class Number
double
value represented by this object
converted to type byte
public short shortValue()
Double
as a
short
(by casting to a short
).
shortValue
in class Number
double
value represented by this object
converted to type short
public int intValue()
Double
as an
int
(by casting to type int
).
intValue
in class Number
double
value represented by this object
converted to type int
public long longValue()
Double
as a
long
(by casting to type long
).
longValue
in class Number
double
value represented by this object
converted to type long
public double doubleValue()
double
value of this
Double
object.
doubleValue
in class Number
double
value represented by this objectpublic float floatValue()
float
value of this
Double
object.
floatValue
in class Number
double
value represented by this object
converted to type float
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 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 static boolean isNaN(double d)
d
- the value to be tested.
true
if the value of the argument is NaN;
false
otherwise.public static boolean isInfinite(double d)
d
- 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 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 floating-point 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: Signopt 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 round-to-nearest rule of IEEE 754 floating-point
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 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
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |