|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object java.lang.Float
public final class Float
The 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
.
Field Summary | |
---|---|
static float |
MAX_VALUE
A constant holding the largest positive finite value of type float , (2-2-23)·2127. |
static float |
MIN_VALUE
A constant holding the smallest positive nonzero value of type float , 2-149. |
static float |
NaN
A constant holding a Not-a-Number (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 . |
Constructor Summary | |
---|---|
Float()
|
Method Summary | |
---|---|
static int |
floatToIntBits(float value)
Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "single format" bit layout. |
static float |
intBitsToFloat(int bits)
Returns the float value corresponding to a given
bit represention. |
static boolean |
isInfinite(float v)
Returns true if the specified number is infinitely
large in magnitude, false otherwise. |
static boolean |
isNaN(float v)
Returns true if the specified number is a
Not-a-Number (NaN) value, false otherwise. |
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 . |
static String |
toString(float f)
Returns a string representation of the float
argument. |
Methods inherited from class java.lang.Object |
---|
clone, equals, getClass, notifyAll, toString, wait |
Field Detail |
---|
public static final float POSITIVE_INFINITY
float
. It is equal to the value returned by
Float.intBitsToFloat(0x7f800000)
.
public static final float NEGATIVE_INFINITY
float
. It is equal to the value returned by
Float.intBitsToFloat(0xff800000)
.
public static final float NaN
float
. It is equivalent to the value returned by
Float.intBitsToFloat(0x7fc00000)
.
public static final float MAX_VALUE
float
, (2-2-23)·2127.
It is equal to the value returned by
Float.intBitsToFloat(0x7f7fffff)
.
public static final float MIN_VALUE
float
, 2-149. It is equal to the value
returned by Float.intBitsToFloat(0x1)
.
Constructor Detail |
---|
public Float()
Method Detail |
---|
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 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.
NumberFormatException
- if the string does not contain a
parsable float
.java.lang.Float#valueOf(String)
public static boolean isNaN(float v)
true
if the specified number is a
Not-a-Number (NaN) value, false
otherwise.
v
- the value to be tested.
true
if the argument is NaN;
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 static int floatToIntBits(float value)
Bit 31 (the bit that is selected by the mask
0x80000000
) represents the sign of the floating-point
number.
Bits 30-23 (the bits that are selected by the mask
0x7f800000
) represent the exponent.
Bits 22-0 (the bits that are selected by the mask
0x007fffff
) represent the significand (sometimes called
the mantissa) of the floating-point 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 floating-point
value the same as the argument to floatToIntBits
(except all NaN values are collapsed to a single
"canonical" NaN value).
value
- a floating-point number.
public static float intBitsToFloat(int bits)
float
value corresponding to a given
bit represention.
The argument is considered to be a representation of a
floating-point value according to the IEEE 754 floating-point
"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
floating-point 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 floating-point result equals the value of the mathematical expression s·m·2e-150.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
floating-point value with the same bit
pattern.
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |