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_INFINITYThe value of a double representation -1.0/0.0, negative infinity. |
static double | NaNAll IEEE 754 values of NaN have the same value in Java. |
static double | POSITIVE_INFINITYThe value of a double representing 1.0/0.0, positive infinity. |
static java.lang.Class | TYPEThe 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_VALUEdouble may represent
is 1.7976931348623157e+308.
public static final double MIN_VALUEdouble may represent
is 5e-324.
public static final double NEGATIVE_INFINITYpublic static final double NaNpublic static final double POSITIVE_INFINITYpublic static final Class TYPEdouble 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
doubleNullPointerException - 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 Doublepublic native static long doubleToLongBits(double value)Double.longBitsToDouble(long) to obtain the original
double value.
value - the double to convertdoublepublic native static long doubleToRawLongBits(double value)Double.longBitsToDouble(long) to obtain the original
double value.
value - the double to convertdoublepublic 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 NaNpublic 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 sNumberFormatException - if s cannot be parsed as a
doubleNullPointerException - 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 doublepublic static Double valueOf(java.lang.String s)Double object using the String.
s - the String to convertDoubleNumberFormatException - if s cannot be parsed as a
doubleNullPointerException - if s is null.
Doublerepresent primitivedoublevalues. Additionally, this class provides various helper functions and variables related to doubles.