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_INFINITY The value of a float representation -1.0/0.0, negative infinity. |
static float | NaN All IEEE 754 values of NaN have the same value in Java. |
static float | POSITIVE_INFINITY The value of a float representation 1.0/0.0, positive infinity. |
static java.lang.Class | TYPE The 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_VALUE
double
may represent
is 3.4028235e+38f.
public static final float MIN_VALUE
float
may represent
is 1.4e-45.
public static final float NEGATIVE_INFINITY
public static final float NaN
public static final float POSITIVE_INFINITY
public static final Class TYPE
float
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
float
NullPointerException
- 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 Float
public 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 convertfloat
public native static int floatToRawIntBits(float value)
Float.intBitsToFloat(int)
to
obtain the original float
value.
value
- the float
to convertfloat
public 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 NaN
public static boolean isNaN(float v)
true
if the float
has the same
value as NaN
, otherwise return false
.
v
- the float
to compareNaN
public 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 s
NumberFormatException
- if s
cannot be parsed as a
float
NullPointerException
- 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 float
public static Float valueOf(java.lang.String s)
Float
object using the String
.
s
- the String
to convertFloat
NumberFormatException
- if s
cannot be parsed as a
float
NullPointerException
- if s
is null
Float
represent primitivefloat
values. Additionally, this class provides various helper functions and variables related to floats.