java.lang.Object | +--java.lang.Number | +--java.lang.FloatAll Implemented Interfaces:
static float | MAX_VALUE The maximum positive value a |
static float | MIN_VALUE The minimum positive value a |
static float | NEGATIVE_INFINITYThe value of a float representation -1.0/0.0, negative infinity. |
static float | NaNAll IEEE 754 values of NaN have the same value in Java. |
static float | POSITIVE_INFINITYThe value of a float representation 1.0/0.0, positive infinity. |
static java.lang.Class | TYPEThe primitive type |
Float(float value)Create a |
Float(double value)Create a |
Float(java.lang.String s)Create a |
byte | byteValue()Return the value of this |
static int | compare(float x, float y) Behaves like |
int | compareTo(java.lang.Float f) Compare two Floats numerically by comparing their |
int | compareTo(java.lang.Object o)Behaves like |
double | doubleValue()Return the value of this |
boolean | equals(java.lang.Object obj)Returns |
static int | floatToIntBits(float value)Convert the float to the IEEE 754 floating-point "single format" bit layout. |
static int | floatToRawIntBits(float value)Convert the float to the IEEE 754 floating-point "single format" bit layout. |
float | floatValue() Return the value of this |
int | hashCode()Return a hashcode representing this Object. |
static float | intBitsToFloat(int bits)Convert the argument in IEEE 754 floating-point "single format" bit layout to the corresponding float. |
int | intValue()Return the value of this |
static boolean | isInfinite(float v)Return |
boolean | isInfinite()Return |
static boolean | isNaN(float v)Return |
boolean | isNaN()Return |
long | longValue()Return the value of this |
static float | parseFloat(java.lang.String s)Parse the specified |
short | shortValue()Return the value of this |
static java.lang.String | toString(float f)Convert the |
java.lang.String | toString()Convert the |
static java.lang.Float | valueOf(java.lang.String s)Creates a new |
public static final float MAX_VALUEdouble may represent
is 3.4028235e+38f.
public static final float MIN_VALUEfloat may represent
is 1.4e-45.
public static final float NEGATIVE_INFINITYpublic static final float NaNpublic static final float POSITIVE_INFINITYpublic static final Class TYPEfloat is represented by this
Class object.
public Float(double value)Float from the primitive double
specified.
value - the double argumentpublic Float(float value)Float from the primitive float
specified.
value - the float argumentpublic Float(java.lang.String s)Float from the specified String.
This method calls Float.parseFloat().
s - the String to convertNumberFormatException - if s cannot be parsed as a
floatNullPointerException - if s is nullpublic byte byteValue()Float as a byte.
public static int compare(float x, float y)new Float(x).compareTo(new Float(y)); in
other words this compares two floats, special casing NaN and zero,
without the overhead of objects.
x - the first float to comparey - the second float to comparepublic int compareTo(java.lang.Float f)float
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 floats, including POSITIVE_INFINITY, and positive
zero is considered greater than negative zero.
f - the Float to comparepublic int compareTo(java.lang.Object o)compareTo(Float) unless the Object
is not an Float.
o - the object to compareClassCastException - if the argument is not a Floatpublic double doubleValue()Float as a double
public boolean equals(java.lang.Object obj)true if obj is an instance of
Float and represents the same float value. Unlike comparing
two floats with ==, this treats two instances of
Float.NaN as equal, but treats 0.0 and
-0.0 as unequal.
Note that f1.equals(f2) is identical to
floatToIntBits(f1.floatValue()) ==
floatToIntBits(f2.floatValue()).
obj - the object to comparepublic native static int floatToIntBits(float value)Float.intBitsToFloat(int) to obtain the
original float value.
value - the float to convertfloatpublic native static int floatToRawIntBits(float value)Float.intBitsToFloat(int) to
obtain the original float value.
value - the float to convertfloatpublic float floatValue()Float.
public int hashCode()Float's hash
code is calculated by calling floatToIntBits(floatValue()).
public native static float intBitsToFloat(int bits)Float.floatToRawIntBits(float).
bits - the bits to convertfloat represented by the bitspublic int intValue()Integer as an int.
public boolean isInfinite()true if the value of this Float
is the same as NEGATIVE_INFINITY or
POSITIVE_INFINITY, otherwise return false.
Float is (-/+) infinitypublic static boolean isInfinite(float v)true if the float has a value
equal to either NEGATIVE_INFINITY or
POSITIVE_INFINITY, otherwise return false.
v - the float to comparepublic boolean isNaN()true if the value of this Float
is the same as NaN, otherwise return false.
Float is NaNpublic static boolean isNaN(float v)true if the float has the same
value as NaN, otherwise return false.
v - the float to compareNaNpublic long longValue()Integer as a long.
public static float parseFloat(java.lang.String s)String as a float. 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 float. 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 convertfloat value of sNumberFormatException - if s cannot be parsed as a
floatNullPointerException - if s is nullpublic short shortValue()Float as a short.
public String toString()float value of this Float
to a String. This method calls
Float.toString(float) to do its dirty work.
String representationpublic static String toString(float f)float 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 Float | 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 float.
To create other output formats, use java.text.NumberFormat.
f - the float to convertString representing the floatpublic static Float valueOf(java.lang.String s)Float object using the String.
s - the String to convertFloatNumberFormatException - if s cannot be parsed as a
floatNullPointerException - if s is null
Floatrepresent primitivefloatvalues. Additionally, this class provides various helper functions and variables related to floats.