|
FlexDoc/Javadoc 2.0 Demo Java Doc |
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.
This is a value-based class; programmers should treat instances that are equal as interchangeable and should not use instances for synchronization, or unpredictable behavior may occur. For example, in a future release, synchronization may fail.
Field Summary |
||
static final int |
The number of bytes used to represent a float value.
|
|
static final int |
Maximum exponent a finite float variable may have.
|
|
static final float |
A constant holding the largest positive finite value of type
float, (2-2-23)·2127.
|
|
static final int |
Minimum exponent a normalized float variable may have.
|
|
static final float |
A constant holding the smallest positive normal value of type
float, 2-126.
|
|
static final float |
A constant holding the smallest positive nonzero value of type
float, 2-149.
|
|
static final float |
A constant holding a Not-a-Number (NaN) value of type
float.
|
|
static final float |
A constant holding the negative infinity of type
float.
|
|
static final float |
A constant holding the positive infinity of type
float.
|
|
static final int |
The number of bits used to represent a float value.
|
|
The Class instance representing the primitive type
float.
|
Constructor Summary |
||
Float(double value)
Deprecated, for removal. It is rarely appropriate to use this constructor.
|
||
Float(float value)
Deprecated, for removal. It is rarely appropriate to use this constructor.
|
||
Deprecated, for removal. It is rarely appropriate to use this constructor.
|
Method Summary |
||
byte |
Returns the value of this Float as a byte after
a narrowing primitive conversion.
|
|
static int |
compare(float f1, float f2)
Compares the two specified float values.
|
|
int |
Compares two Float objects numerically.
|
|
Returns an Optional containing the nominal descriptor for this
instance, which is the instance itself.
|
||
double |
Returns the value of this Float as a double
after a widening primitive conversion.
|
|
boolean |
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 |
Returns the float value of this Float object.
|
|
int |
hashCode()
Returns a hash code for this Float object.
|
|
static int |
hashCode(float value)
Returns a hash code for a float value; compatible with
Float.hashCode().
|
|
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 after
a narrowing primitive conversion.
|
|
static boolean |
isFinite(float f)
Returns true if the argument is a finite floating-point
value; returns false otherwise (for NaN and infinity
arguments).
|
|
boolean |
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 |
Returns value of this Float as a long after a
narrowing primitive conversion.
|
|
static float |
max(float a, float b)
Returns the greater of two float values
as if by calling Math.max.
|
|
static float |
min(float a, float b)
Returns the smaller of two float values
as if by calling Math.min.
|
|
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.
|
|
Resolves this instance as a ConstantDesc, the result of which is
the instance itself.
|
||
short |
Returns the value of this Float as a short
after a narrowing primitive conversion.
|
|
static float |
sum(float a, float b)
Adds two float values together as per the + operator.
|
|
static String |
toHexString(float f)
Returns a hexadecimal string representation of the
float argument.
|
|
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 |
Returns a Float object holding the
float value represented by the argument string
s.
|
Methods inherited from class java.lang.Object |
public Float |
(float value) |
public Float |
(double value) |
public Float |
(String s) |
throws |
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 |
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 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. Note that the round-to-nearest 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.
- FloatValue:
- Signopt NaN
- Signopt Infinity
- Signopt FloatingPointLiteral
- Signopt HexFloatingPointLiteral
- SignedInteger
- HexFloatingPointLiteral:
- HexSignificand BinaryExponent FloatTypeSuffixopt
- HexSignificand:
- HexNumeral
- HexNumeral .
- 0x HexDigitsopt . HexDigits
- 0X HexDigitsopt . 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.0000001f
results.
To avoid calling this method on an 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 |
public static boolean isNaN |
(float v) |
public static boolean isInfinite |
(float v) |
public static boolean isFinite |
(float f) |
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 static int hashCode |
(float value) |
public boolean equals |
(Object obj) |
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 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·2e-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))
public static float sum |
(float a, float b) |
public static float max |
(float a, float b) |
public static float min |
(float a, float b) |
() |
public Float resolveConstantDesc |
(MethodHandles.Lookup lookup) |
|
FlexDoc/Javadoc 2.0 Demo Java Doc |