java.lang.Object | +--java.lang.Number | +--java.lang.DoubleAll Implemented Interfaces:
static double | MAX_VALUE The maximum positive value a |
static double | MIN_VALUE The minimum positive value a |
static double | NEGATIVE_INFINITY The value of a double representation -1.0/0.0, negative infinity. |
static double | NaN All IEEE 754 values of NaN have the same value in Java. |
static double | POSITIVE_INFINITY The value of a double representing 1.0/0.0, positive infinity. |
static java.lang.Class | TYPE The primitive type |
Double(double value) Create a |
Double(java.lang.String s) Create a |
byte | byteValue() Return the value of this |
static int | compare(double x, double y) Behaves like |
int | compareTo(java.lang.Double d) Compare two Doubles numerically by comparing their |
int | compareTo(java.lang.Object o) Behaves like |
static long | doubleToLongBits(double value) Convert the double to the IEEE 754 floating-point "double format" bit layout. |
static long | doubleToRawLongBits(double value) Convert the double to the IEEE 754 floating-point "double format" bit layout. |
double | doubleValue() Return the value of this |
boolean | equals(java.lang.Object obj) Returns |
float | floatValue() Return the value of this |
int | hashCode() Return a hashcode representing this Object. |
int | intValue() Return the value of this |
static boolean | isInfinite(double v) Return |
boolean | isInfinite() Return |
static boolean | isNaN(double v) Return |
boolean | isNaN() Return |
static double | longBitsToDouble(long bits) Convert the argument in IEEE 754 floating-point "double format" bit layout to the corresponding float. |
long | longValue() Return the value of this |
static double | parseDouble(java.lang.String s) Parse the specified |
short | shortValue() Return the value of this |
static java.lang.String | toString(double d) Convert the |
java.lang.String | toString() Convert the |
static java.lang.Double | valueOf(java.lang.String s) Create a new |
public static final double MAX_VALUE
double
may represent
is 1.7976931348623157e+308.
public static final double MIN_VALUE
double
may represent
is 5e-324.
public static final double NEGATIVE_INFINITY
public static final double NaN
public static final double POSITIVE_INFINITY
public static final Class TYPE
double
is represented by this
Class
object.
public Double(double value)
Double
from the primitive double
specified.
value
- the double
argumentpublic Double(java.lang.String s)
Double
from the specified String
.
This method calls Double.parseDouble()
.
s
- the String
to convertNumberFormatException
- if s
cannot be parsed as a
double
NullPointerException
- if s
is nullpublic byte byteValue()
Double
as a byte
.
public static int compare(double x, double y)
new Double(x).compareTo(new Double(y))
; in
other words this compares two doubles, special casing NaN and zero,
without the overhead of objects.
x
- the first double to comparey
- the second double to comparepublic int compareTo(java.lang.Double d)
double
values. The result is positive if the first is greater, negative if the
second is greater, and 0 if the two are equal. However, this special
cases NaN and signed zero as follows: NaN is considered greater than
all other doubles, including POSITIVE_INFINITY
, and positive
zero is considered greater than negative zero.
d
- the Double to comparepublic int compareTo(java.lang.Object o)
compareTo(Double)
unless the Object
is not an Double
.
o
- the object to compareClassCastException
- if the argument is not a Double
public native static long doubleToLongBits(double value)
Double.longBitsToDouble(long)
to obtain the original
double
value.
value
- the double
to convertdouble
public native static long doubleToRawLongBits(double value)
Double.longBitsToDouble(long)
to obtain the original
double
value.
value
- the double
to convertdouble
public double doubleValue()
Double
.
public boolean equals(java.lang.Object obj)
true
if obj
is an instance of
Double
and represents the same double value. Unlike comparing
two doubles with ==
, this treats two instances of
Double.NaN
as equal, but treats 0.0
and
-0.0
as unequal.
Note that d1.equals(d2)
is identical to
doubleToLongBits(d1.doubleValue()) ==
doubleToLongBits(d2.doubleValue())
.
obj
- the object to comparepublic float floatValue()
Double
as a float
.
public int hashCode()
Double
's hash
code is calculated by:long v = Double.doubleToLongBits(doubleValue());
int hash = (int)(v^(v>>32))
.
public int intValue()
Double
as an int
.
public boolean isInfinite()
true
if the value of this Double
is the same as NEGATIVE_INFINITY
or
POSITIVE_INFINITY
, otherwise return false
.
Double
is (-/+) infinitypublic static boolean isInfinite(double v)
true
if the double
has a value
equal to either NEGATIVE_INFINITY
or
POSITIVE_INFINITY
, otherwise return false
.
v
- the double
to comparepublic boolean isNaN()
true
if the value of this Double
is the same as NaN
, otherwise return false
.
Double
is NaN
public static boolean isNaN(double v)
true
if the double
has the same
value as NaN
, otherwise return false
.
v
- the double
to compareNaN
.public native static double longBitsToDouble(long bits)
Double.doubleToRawLongBits(double)
.
bits
- the bits to convertdouble
represented by the bitspublic long longValue()
Double
as a long
.
public native static double parseDouble(java.lang.String s)
String
as a double
. The
extended BNF grammar is as follows:DecodableString: ( [-
|+
]NaN
) | ( [-
|+
]Infinity
) | ( [-
|+
] FloatingPoint [f
|F
|d
|D
] ) FloatingPoint: ( { Digit }+ [.
{ Digit } ] [ Exponent ] ) | (.
{ Digit }+ [ Exponent ] ) Exponent: ( (e
|E
) [-
|+
] { Digit }+ ) Digit:'0'
through'9'
NaN and infinity are special cases, to allow parsing of the output of toString. Otherwise, the result is determined by calculating n * 10exponent to infinite precision, then rounding to the nearest double. Remember that many numbers cannot be precisely represented in floating point. In case of overflow, infinity is used, and in case of underflow, signed zero is used. Unlike Integer.parseInt, this does not accept Unicode digits outside the ASCII range.
If an unexpected character is found in the String
, a
NumberFormatException
will be thrown. Leading and trailing
'whitespace' is ignored via String.trim()
, but spaces
internal to the actual number are not allowed.
To parse numbers according to another format, consider using java.text.NumberFormat.
s
- the String
to convertdouble
value of s
NumberFormatException
- if s
cannot be parsed as a
double
NullPointerException
- if s
is nullpublic short shortValue()
Double
as a short
.
public String toString()
double
value of this Double
to a String
. This method calls
Double.toString(double)
to do its dirty work.
String
representationpublic static String toString(double d)
double
to a String
.
Floating-point string representation is fairly complex: here is a
rundown of the possible values. "[-]
" indicates that a
negative sign will be printed if the value (or exponent) is negative.
"<number>
" means a string of digits ('0' to '9').
"<digit>
" means a single digit ('0' to '9').Value of Double | String Representation |
---|---|
[+-] 0 | [-]0.0 |
Between [+-] 10-3 and 107, exclusive | [-]number.number |
Other numeric value | [-]<digit>.<number>
E[-]<number> |
[+-] infinity | [-]Infinity |
NaN | NaN |
.
and at least one digit printed after
it: even if the number is 3, it will be printed as 3.0
.
After the ".", all digits will be printed except trailing zeros. The
result is rounded to the shortest decimal number which will parse back
to the same double.
To create other output formats, use java.text.NumberFormat.
d
- the double
to convertString
representing the double
public static Double valueOf(java.lang.String s)
Double
object using the String
.
s
- the String
to convertDouble
NumberFormatException
- if s
cannot be parsed as a
double
NullPointerException
- if s
is null.
Double
represent primitivedouble
values. Additionally, this class provides various helper functions and variables related to doubles.