Methods Summary 

public byte  byteValue()Returns the value of this Float as a byte (by casting to a byte).
return (byte)value;

public double  doubleValue()Returns the double value of this Float object.
return (double)value;

public boolean  equals(java.lang.Object obj)Compares this object against some other object.
The result is true if and only if the argument is
not null and is a Float object that
represents a float that has the identical bit pattern
to the bit pattern of the float represented by this
object. For this purpose, two float values are considered to be
the same if and only if the method {@link #floatToIntBits(float)}
returns the same 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:
 If
f1 and f2 both represent
Float.NaN , then the equals method returns
true , even though Float.NaN==Float.NaN
has the value false .
 If
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 .
This definition allows hashtables to operate properly.
return (obj instanceof Float)
&& (floatToIntBits(((Float)obj).value) == floatToIntBits(value));

public static native int  floatToIntBits(float value)Returns the bit representation of a singlefloat value.
The result is a representation of the floatingpoint argument
according to the IEEE 754 floatingpoint "single
precision" bit layout.
 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
{@link #intBitsToFloat(int)} method, will produce a floatingpoint
value equal to the argument to floatToIntBits .

public float  floatValue()Returns the float value of this Float object.
return value;

public int  hashCode()Returns a hashcode for this Float object. The result
is the integer bit representation, exactly as produced
by the method {@link #floatToIntBits(float)}, of the primitive float
value represented by this Float object.
return floatToIntBits(value);

public static native float  intBitsToFloat(int bits)Returns the singlefloat 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 precision" 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
NaN. All IEEE 754 NaN values of type float are, in effect,
lumped together by the Java programming language into a single
float value called NaN.
In all other cases, let s, e, and m be three
values that can be computed from the argument:
int s = ((bits >> 31) == 0) ? 1 : 1;
int e = ((bits >> 23) & 0xff);
int m = (e == 0) ?
(bits & 0x7fffff) << 1 :
(bits & 0x7fffff)  0x800000;
Then the floatingpoint result equals the value of the mathematical
expression s·m·2^{e150}.

public int  intValue()Returns the integer value of this Float (by casting to an int).
return (int)value;

public static boolean  isInfinite(float v)Returns true if the specified number is infinitely large in magnitude.
return (v == POSITIVE_INFINITY)  (v == NEGATIVE_INFINITY);

public boolean  isInfinite()Returns true if this Float value is infinitely large in magnitude.
return isInfinite(value);

public static boolean  isNaN(float v)Returns true if the specified number is the special NotaNumber (NaN)
value.
return (v != v);

public boolean  isNaN()Returns true if this Float value is NotaNumber (NaN).
return isNaN(value);

public long  longValue()Returns the long value of this Float (by casting to a long).
return (long)value;

public static float  parseFloat(java.lang.String s)Returns a new float initialized to the value represented by the
specified String .
return FloatingDecimal.readJavaFormatString(s).floatValue();

public short  shortValue()Returns the value of this Float as a short (by casting to a short).
return (short)value;

public static java.lang.String  toString(float f)Returns a String representation for the specified float value.
The argument is converted to a readable string format as follows.
All characters and characters in strings mentioned below are ASCII
characters.

public java.lang.String  toString()Returns a String representation of this 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.
return String.valueOf(value);

public static java.lang.Float  valueOf(java.lang.String s)Returns the floating point value represented by the specified String.
The string s is interpreted as the representation of a
floatingpoint value and a Float object representing that
value is created and returned.
If s is null , then a
NullPointerException is thrown.
Leading and trailing whitespace characters in s are ignored. The rest
of s should constitute a FloatValue as described
by the lexical syntax rules:
FloatValue:
Sign_{opt} FloatingPointLiteral
where Sign, FloatingPointLiteral are as defined in
Section 3.10.2 of the
Java Language
Specification. If it does not have the form of a FloatValue,
then a NumberFormatException is thrown. Otherwise, it is
regarded as representing an exact decimal value in the usual
"computerized scientific notation"; this exact decimal 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.
return new Float(FloatingDecimal.readJavaFormatString(s).floatValue());
