public final class Float extends Number implements Comparable<Float>
Float
class wraps a value of primitive type float
in an object. An object of
type Float
contains a single field whose type is float
.
In addition, this class provides several methods for converting a float
to a
String
and a String
to a float
, as well as other constants and methods
useful when dealing with a float
.
Modifier and Type  Field and Description 

static int 
MAX_EXPONENT
Maximum exponent a finite
float variable may have. 
static float 
MAX_VALUE
A constant holding the largest positive finite value of type
float ,
(22^{23})·2^{127}. 
static int 
MIN_EXPONENT
Minimum exponent a normalized
float variable may have. 
static float 
MIN_NORMAL
A constant holding the smallest positive normal value of type
float ,
2^{126}. 
static float 
MIN_VALUE
A constant holding the smallest positive nonzero value of type
float ,
2^{149}. 
static float 
NaN
A constant holding a NotaNumber (NaN) value of type
float . 
static float 
NEGATIVE_INFINITY
A constant holding the negative infinity of type
float . 
static float 
POSITIVE_INFINITY
A constant holding the positive infinity of type
float . 
static int 
SIZE
The number of bits used to represent a
float value. 
Constructor and Description 

Float(double value)
Constructs a newly allocated
Float object that represents the argument converted to
type float . 
Float(float value)
Constructs a newly allocated
Float object that represents the primitive float
argument. 
Float(String s)
Constructs a newly allocated
Float object that represents the floatingpoint value of
type float represented by the string. 
Modifier and Type  Method and Description 

byte 
byteValue()
Returns the value of this
Float as a byte (by casting to a byte ). 
static int 
compare(float f1,
float f2)
Compares the two specified
float values. 
int 
compareTo(Float anotherFloat)
Compares two
Float objects numerically. 
double 
doubleValue()
Returns the
double value of this Float object. 
boolean 
equals(Object obj)
Compares this object against the specified object.

static int 
floatToIntBits(float value)
Returns a representation of the specified floatingpoint value according to the IEEE 754
floatingpoint "single format" bit layout.

static int 
floatToRawIntBits(float value)
Returns a representation of the specified floatingpoint value according to the IEEE 754
floatingpoint "single format" bit layout, preserving NotaNumber (NaN) values.

float 
floatValue()
Returns the
float value of this Float object. 
int 
hashCode()
Returns a hash code for this
Float object. 
static float 
intBitsToFloat(int bits)
Returns the
float value corresponding to a given bit representation. 
int 
intValue()
Returns the value of this
Float as an int (by casting to type int ). 
boolean 
isInfinite()
Returns
true if this Float value is infinitely large in magnitude,
false otherwise. 
static boolean 
isInfinite(float v)
Returns
true if the specified number is infinitely large in magnitude, false
otherwise. 
boolean 
isNaN()
Returns
true if this Float value is a NotaNumber (NaN), false
otherwise. 
static boolean 
isNaN(float v)
Returns
true if the specified number is a NotaNumber (NaN) value, false
otherwise. 
long 
longValue()
Returns value of this
Float as a long (by casting to type long ). 
static float 
parseFloat(String s)
Returns a new
float initialized to the value represented by the specified
String , as performed by the valueOf method of class Float . 
short 
shortValue()
Returns the value of this
Float as a short (by casting to a short ). 
String 
toString()
Returns a string representation of this
Float object. 
static String 
toString(float f)
Returns a string representation of the
float argument. 
static Float 
valueOf(float f)
Returns a
Float instance representing the specified float value. 
static Float 
valueOf(String s)
Returns a
Float object holding the float value represented by the argument
string s . 
public static final int MAX_EXPONENT
float
variable may have. It is equal to the value returned
by Math.getExponent(Float.MAX_VALUE)
.public static final float MAX_VALUE
float
,
(22^{23})·2^{127}. It is equal to the hexadecimal floatingpoint
literal 0x1.fffffeP+127f
and also equal to Float.intBitsToFloat(0x7f7fffff)
.public static final int MIN_EXPONENT
float
variable may have. It is equal to the value
returned by Math.getExponent(Float.MIN_NORMAL)
.public static final float MIN_NORMAL
float
,
2^{126}. It is equal to the hexadecimal floatingpoint literal 0x1.0p126f
and also equal to Float.intBitsToFloat(0x00800000)
.public static final float MIN_VALUE
float
,
2^{149}. It is equal to the hexadecimal floatingpoint literal
0x0.000002P126f
and also equal to Float.intBitsToFloat(0x1)
.public static final float NaN
float
. It is equivalent to the
value returned by Float.intBitsToFloat(0x7fc00000)
.public static final float NEGATIVE_INFINITY
float
. It is equal to the value
returned by Float.intBitsToFloat(0xff800000)
.public static final float POSITIVE_INFINITY
float
. It is equal to the value
returned by Float.intBitsToFloat(0x7f800000)
.public static final int SIZE
float
value.public Float(double value)
Float
object that represents the argument converted to
type float
.value
 the value to be represented by the Float
.public Float(float value)
Float
object that represents the primitive float
argument.value
 the value to be represented by the Float
.public Float(String s) throws NumberFormatException
Float
object that represents the floatingpoint value of
type float
represented by the string. The string is converted to a float
value as if by the valueOf
method.s
 a string to be converted to a Float
.NumberFormatException
 if the string does not contain a parsable number.valueOf(java.lang.String)
public static int compare(float f1, float f2)
float
values. The sign of the integer value returned is
the same as that of the integer that would be returned by the call:
new Float(f1).compareTo(new Float(f2))
f1
 the first float
to compare.f2
 the second float
to compare.0
if f1
is numerically equal to f2
; a value less
than 0
if f1
is numerically less than f2
; and a value greater
than 0
if f1
is numerically greater than f2
.public static int floatToIntBits(float value)
Bit 31 (the bit that is selected by the mask 0x80000000
) represents the sign of the
floatingpoint number. Bits 3023 (the bits that are selected by the mask 0x7f800000
)
represent the exponent. Bits 220 (the bits that are selected by the mask 0x007fffff
)
represent the significand (sometimes called the mantissa) of the floatingpoint number.
If the argument is positive infinity, the result is 0x7f800000
.
If the argument is negative infinity, the result is 0xff800000
.
If the argument is NaN, the result is 0x7fc00000
.
In all cases, the result is an integer that, when given to the intBitsToFloat(int)
method, will produce a floatingpoint value the same as the argument to
floatToIntBits
(except all NaN values are collapsed to a single "canonical" NaN
value).
value
 a floatingpoint number.public static int floatToRawIntBits(float value)
Bit 31 (the bit that is selected by the mask 0x80000000
) represents the sign of the
floatingpoint number. Bits 3023 (the bits that are selected by the mask 0x7f800000
)
represent the exponent. Bits 220 (the bits that are selected by the mask 0x007fffff
)
represent the significand (sometimes called the mantissa) of the floatingpoint number.
If the argument is positive infinity, the result is 0x7f800000
.
If the argument is negative infinity, the result is 0xff800000
.
If the argument is NaN, the result is the integer representing the actual NaN value. Unlike
the floatToIntBits
method, floatToRawIntBits
does not collapse all the bit
patterns encoding a NaN to a single "canonical" NaN value.
In all cases, the result is an integer that, when given to the intBitsToFloat(int)
method, will produce a floatingpoint value the same as the argument to
floatToRawIntBits
.
value
 a floatingpoint number.public static float intBitsToFloat(int bits)
float
value corresponding to a given bit representation. The argument is
considered to be a representation of a floatingpoint value according to the IEEE 754
floatingpoint "single format" bit layout.
If the argument is 0x7f800000
, the result is positive infinity.
If the argument is 0xff800000
, the result is negative infinity.
If the argument is any value in the range 0x7f800001
through 0x7fffffff
or in
the range 0xff800001
through 0xffffffff
, the result is a NaN. No IEEE 754
floatingpoint operation provided by Java can distinguish between two NaN values of the same
type with different bit patterns. Distinct values of NaN are only distinguishable by use of
the Float.floatToRawIntBits
method.
In all other cases, let s, e, and m be three values that can be computed from the argument:
Then the floatingpoint result equals the value of the mathematical expression s·m·2^{e150}.int s = ((bits >> 31) == 0) ? 1 : 1; int e = ((bits >> 23) & 0xff); int m = (e == 0) ? (bits & 0x7fffff) << 1 : (bits & 0x7fffff)  0x800000;
Note that this method may not be able to return a float
NaN with exactly same bit
pattern as the int
argument. IEEE 754 distinguishes between two kinds of NaNs, quiet
NaNs and signaling NaNs. The differences between the two kinds of NaN are generally
not visible in Java. Arithmetic operations on signaling NaNs turn them into quiet NaNs with a
different, but often similar, bit pattern. However, on some processors merely copying a
signaling NaN also performs that conversion. In particular, copying a signaling NaN to return
it to the calling method may perform this conversion. So intBitsToFloat
may not be
able to return a float
with a signaling NaN bit pattern. Consequently, for some
int
values, floatToRawIntBits(intBitsToFloat(start))
may not equal
start
. Moreover, which particular bit patterns represent signaling NaNs is platform
dependent; although all NaN bit patterns, quiet or signaling, must be in the NaN range
identified above.
bits
 an integer.float
floatingpoint value with the same bit pattern.public static boolean isInfinite(float v)
true
if the specified number is infinitely large in magnitude, false
otherwise.v
 the value to be tested.true
if the argument is positive infinity or negative infinity; false
otherwise.public static boolean isNaN(float v)
true
if the specified number is a NotaNumber (NaN) value, false
otherwise.v
 the value to be tested.true
if the argument is NaN; false
otherwise.public static float parseFloat(String s) throws NumberFormatException
float
initialized to the value represented by the specified
String
, as performed by the valueOf
method of class Float
.s
 the string to be parsed.float
value represented by the string argument.NullPointerException
 if the string is nullNumberFormatException
 if the string does not contain a parsable float
.valueOf(String)
public static String toString(float f)
float
argument. All characters mentioned below
are ASCII characters.
NaN
".

' (
'\u002D'
); 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"
.
.
' ('\u002E'
), followed by one or more decimal
digits representing the fractional part of m.
.
' (
'\u002E'
), followed by decimal digits representing the fractional part of
a, followed by the letter 'E
' ('\u0045'
), followed by a
representation of n as a decimal integer, as produced by the method
Integer.toString(int)
.
float
. That is, suppose that x is the exact mathematical value
represented by the decimal representation produced by this method for a finite nonzero
argument f. Then f must be the float
value nearest to x; or, if
two float
values are equally close to x, then f must be one of them and
the least significant bit of the significand of f must be 0
.f
 the float to be converted.public static Float valueOf(float f)
Float
instance representing the specified float
value. If a new
Float
instance is not required, this method should generally be used in preference to
the constructor Float(float)
, as this method is likely to yield significantly better
space and time performance by caching frequently requested values.f
 a float value.Float
instance representing f
.public static Float valueOf(String s) throws NumberFormatException
Float
object holding the float
value represented by the argument
string s
.
If s
is null
, then a NullPointerException
is thrown.
Leading and trailing whitespace characters in s
are ignored. Whitespace is removed as
if by the String.trim()
method; that is, both ASCII space and control characters are
removed. The rest of s
should constitute a FloatValue as described by the
lexical syntax rules:
where Sign, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger and FloatTypeSuffix are as defined in the lexical structure sections of The Java™ Language Specification, except that underscores are not accepted between digits. If
 FloatValue:
 Sign_{opt}
NaN
 Sign_{opt}
Infinity
 Sign_{opt} FloatingPointLiteral
 Sign_{opt} HexFloatingPointLiteral
 SignedInteger
 HexFloatingPointLiteral:
 HexSignificand BinaryExponent FloatTypeSuffix_{opt}
 HexSignificand:
 HexNumeral
 HexNumeral
.
0x
HexDigits_{opt}.
HexDigits0X
HexDigits_{opt}.
HexDigits
 BinaryExponent:
 BinaryExponentIndicator SignedInteger
 BinaryExponentIndicator:
p
P
s
does not have the form of a FloatValue, then
a NumberFormatException
is thrown. Otherwise, s
is regarded as representing
an exact decimal value in the usual "computerized scientific notation" or as an exact
hexadecimal value; this exact numerical value is then conceptually converted to an
"infinitely precise" binary value that is then rounded to type float
by the usual
roundtonearest rule of IEEE 754 floatingpoint arithmetic, which includes preserving the
sign of a zero value.
Note that the roundtonearest rule also implies overflow and underflow behaviour; if the
exact value of s
is large enough in magnitude (greater than or equal to (
MAX_VALUE
+ ulp(MAX_VALUE)
/2), rounding to float
will result in an infinity and if the exact value of s
is small enough in magnitude
(less than or equal to MIN_VALUE
/2), rounding to float will result in a zero.
Finally, after rounding a Float
object representing this float
value is
returned.
Note that trailing format specifiers, specifiers that determine the type of a floatingpoint
literal (1.0f
is a float
value; 1.0d
is a double
value), do
not influence the results of this method. In other words, the numerical value of the
input string is converted directly to the target floatingpoint type. In general, the
twostep sequence of conversions, string to double
followed by double
to
float
, is not equivalent to converting a string directly to float
.
For example, if first converted to an intermediate double
and then to float
,
the string
"1.00000017881393421514957253748434595763683319091796875001d"
results in the float
value 1.0000002f
; if the string is converted directly to
float
, 1.0000001f
results.
s
 the string to be parsed.Float
object holding the value represented by the String
argument.NumberFormatException
 if the string does not contain a parsable number.public byte byteValue()
Float
as a byte
(by casting to a byte
).public int compareTo(Float anotherFloat)
Float
objects numerically. There are two ways in which comparisons
performed by this method differ from those performed by the Java language numerical
comparison operators (<, <=, ==, >=, >
) when applied to primitive float
values:
Float.NaN
is considered by this method to be equal to itself and greater than all
other float
values (including Float.POSITIVE_INFINITY
).
0.0f
is considered by this method to be greater than 0.0f
.
Float
objects imposed by this method
is consistent with equals.compareTo
in interface Comparable<Float>
anotherFloat
 the Float
to be compared.0
if anotherFloat
is numerically equal to this
Float
; a value less than 0
if this Float
is numerically less
than anotherFloat
; and a value greater than 0
if this Float
is numerically greater than anotherFloat
.Comparable.compareTo(Object)
public double doubleValue()
double
value of this Float
object.doubleValue
in class Number
float
value represented by this object is converted to type
double
and the result of the conversion is returned.public boolean equals(Object obj)
true
if and only if
the argument is not null
and is a Float
object that represents a
float
with the same value as the float
represented by this object. For this
purpose, two float
values are considered to be the same if and only if the method
floatToIntBits(float)
returns the identical int
value when applied to each.
Note that in most cases, for two instances of class Float
, f1
and f2
,
the value of f1.equals(f2)
is true
if and only if
f1.floatValue() == f2.floatValue()
also has the value true
. However, there are two exceptions:
f1
and f2
both represent Float.NaN
, then the equals
method returns true
, even though Float.NaN==Float.NaN
has the value
false
.
f1
represents +0.0f
while f2
represents 0.0f
, or vice
versa, the equal
test has the value false
, even though 0.0f==0.0f
has the value true
.
equals
in class Object
obj
 the object to be comparedtrue
if the objects are the same; false
otherwise.floatToIntBits(float)
public float floatValue()
float
value of this Float
object.floatValue
in class Number
float
value represented by this objectpublic int hashCode()
Float
object. The result is the integer bit
representation, exactly as produced by the method floatToIntBits(float)
, of the
primitive float
value represented by this Float
object.hashCode
in class Object
Object.equals(java.lang.Object)
,
System.identityHashCode(java.lang.Object)
public int intValue()
Float
as an int
(by casting to type int
).public boolean isInfinite()
true
if this Float
value is infinitely large in magnitude,
false
otherwise.true
if the value represented by this object is positive infinity or negative
infinity; false
otherwise.public boolean isNaN()
true
if this Float
value is a NotaNumber (NaN), false
otherwise.true
if the value represented by this object is NaN; false
otherwise.public long longValue()
Float
as a long
(by casting to type long
).public short shortValue()
Float
as a short
(by casting to a short
).shortValue
in class Number
float
value represented by this object converted to type short
public String toString()
Float
object. The primitive float
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(float)