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 byte byteValue()
Float
as a byte
(by casting to a byte
).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 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(@Nullable 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 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 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 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 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 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 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 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 long longValue()
Float
as a long
(by casting to type long
).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 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)
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.