java.lang.Number
java.lang.Float
is new.
java.lang.Object
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 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, (2-2 -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 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. |
| static int |
SIZE
The number of bits used to represent a float value. |
| static Class < Float > |
TYPE
The Class instance representing the primitive type float. |
| Constructor Summary | |
|---|---|
|
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 floating-point value of type float represented by the string. |
|
| Method Summary | |
|---|---|
| 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 floating-point value according to the IEEE 754 floating-point "single format" bit layout. |
| static int |
floatToRawIntBits
(float value) Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "single format" bit layout, preserving Not-a-Number (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 Not-a-Number (NaN), false otherwise. |
| static boolean |
isNaN
(float v) Returns true if the specified number is a Not-a-Number (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). |
| static String |
toHexString
(float f) Returns a hexadecimal string representation of the float argument. |
| 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. |
| Methods inherited from class java.lang. Object |
|---|
| clone , finalize , getClass , notify , notifyAll , wait , wait , wait |
| Field Detail |
|---|
public static final float POSITIVE_INFINITY
public static final float NEGATIVE_INFINITY
public static final float NaN
public static final float MAX_VALUE
MIN_NORMAL
A constant holding the smallest positive normal value of type float, 2
-126
. It is equal to the hexadecimal floating-point literal 0x1.0p-126f and also equal to Float.intBitsToFloat(0x00800000).
Since:
1.6
See Also:
Constant Field Values
public static final float MIN_VALUE
MAX_EXPONENT
Maximum exponent a finite float variable may have. It is equal to the value returned by Math.getExponent(Float.MAX_VALUE).
Since:
1.6
See Also:
Constant Field Values
MIN_EXPONENT
Minimum exponent a normalized float variable may have. It is equal to the value returned by Math.getExponent(Float.MIN_NORMAL).
Since:
1.6
See Also:
Constant Field Values
public static final int SIZE
public static final Class<Float> TYPE
| Constructor Detail |
|---|
public Float(float value)
public Float(double value)
public Float(String s)
throws NumberFormatException
| Method Detail |
|---|
public static String toString(float f)
To create localized string representations of a floating-point value, use subclasses of NumberFormat .
public static String toHexString(float f)
| Floating-point Value | Hexadecimal String |
|---|---|
| 1.0 | 0x1.0p0 |
| -1.0 | -0x1.0p0 |
| 2.0 | 0x1.0p1 |
| 3.0 | 0x1.8p1 |
| 0.5 | 0x1.0p-1 |
| 0.25 | 0x1.0p-2 |
| Float.MAX_VALUE | 0x1.fffffep127 |
| Minimum Normal Value | 0x1.0p-126 |
| Maximum Subnormal Value | 0x0.fffffep-126 |
| Float.MIN_VALUE | 0x0.000002p-126 |
public static Float valueOf(String s)
throws NumberFormatException
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 of the Java Language Specification . If 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 round-to-nearest rule of IEEE 754 floating-point arithmetic, which includes preserving the sign of a zero value. Finally, a Float object representing this float value is returned.
- 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 . HexDigits
- 0X HexDigits opt . HexDigits
- BinaryExponent:
- BinaryExponentIndicator SignedInteger
- BinaryExponentIndicator:
- p
- P
To interpret localized string representations of a floating-point value, use subclasses of NumberFormat .
Note that trailing format specifiers, specifiers that determine the type of a floating-point 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 floating-point type. In general, the two-step 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.000000
1
f results.
To avoid calling this method on a invalid string and having a NumberFormatException be thrown, the documentation for Double.valueOf lists a regular expression which can be used to screen the input.
public static Float valueOf(float f)
public static float parseFloat(String s)
throws NumberFormatException
public static boolean isNaN(float v)
public static boolean isInfinite(float v)
public boolean isNaN()
public boolean isInfinite()
public String toString()
public byte byteValue()
public short shortValue()
public int intValue()
public long longValue()
public float floatValue()
public double doubleValue()
public int hashCode()
public boolean equals(Object obj)
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:
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).
public static int floatToRawIntBits(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 the integer representing the actual NaN value. Unlike the floatToIntBits method,
floatToRawIntBits
intToRawIntBits
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 floating-point value the same as the argument to floatToRawIntBits.
public static float intBitsToFloat(int bits)
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:
int s = ((bits >> 31) == 0) ? 1 : -1;
int e = ((bits >> 23) & 0xff);
int m = (e == 0) ?
(bits & 0x7fffff) << 1 :
(bits & 0x7fffff) | 0x800000;
Then the floating-point result equals the value of the mathematical expression
s
·
m
·2
e
-150
.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.
public int compareTo(Float anotherFloat)
public static int compare(float f1,
float f2)
new Float(f1).compareTo(new Float(f2))