public final class Float extends Number
Float
represent primitive
float
values.
Additionally, this class provides various helper functions and variables
related to floats.Modifier and Type | Field and Description |
---|---|
static float |
MAX_VALUE
The maximum positive value a
double may represent
is 3.4028235e+38f. |
static float |
MIN_VALUE
The minimum positive value a
float may represent
is 1.4e-45. |
static float |
NaN
All IEEE 754 values of NaN have the same value in Java.
|
static float |
NEGATIVE_INFINITY
The value of a float representation -1.0/0.0, negative infinity.
|
static float |
POSITIVE_INFINITY
The value of a float representation 1.0/0.0, positive infinity.
|
static Class |
TYPE
The primitive type
float is represented by this
Class object. |
Constructor and Description |
---|
Float(double value)
Create a
Float from the primitive double
specified. |
Float(float value)
Create a
Float from the primitive float
specified. |
Float(String s)
Create a
Float from the specified String . |
Modifier and Type | Method and Description |
---|---|
byte |
byteValue()
Return the value of this
Float as a byte . |
static int |
compare(float n1,
float n2)
Compare two numbers.
|
double |
doubleValue()
Return the value of this
Float as a double |
boolean |
equals(Object obj)
Returns
true if obj is an instance of
Float and represents the same float value. |
static int |
floatToIntBits(float value)
Convert the float to the IEEE 754 floating-point "single format" bit
layout.
|
static int |
floatToRawIntBits(float value)
Convert the float to the IEEE 754 floating-point "single format" bit
layout.
|
float |
floatValue()
Return the value of this
Float . |
int |
hashCode()
Return a hashcode representing this Object.
|
static float |
intBitsToFloat(int bits)
Convert the argument in IEEE 754 floating-point "single format" bit
layout to the corresponding float.
|
int |
intValue()
Return the value of this
Integer as an int . |
boolean |
isInfinite()
Return
true if the value of this Float
is the same as NEGATIVE_INFINITY or
POSITIVE_INFINITY , otherwise return false . |
static boolean |
isInfinite(float v)
Return
true if the float has a value
equal to either NEGATIVE_INFINITY or
POSITIVE_INFINITY , otherwise return false . |
boolean |
isNaN()
Return
true if the value of this Float
is the same as NaN , otherwise return false . |
static boolean |
isNaN(float v)
Return
true if the float has the same
value as NaN , otherwise return false . |
long |
longValue()
Return the value of this
Integer as a long . |
static float |
parseFloat(String s)
Parse the specified
String as a float . |
short |
shortValue()
Return the value of this
Float as a short . |
String |
toString()
Convert the
float value of this Float
to a String . |
static String |
toString(float f)
Convert the
float to a String . |
static Float |
valueOf(String s)
Creates a new
Float object using the String . |
public static final float MAX_VALUE
double
may represent
is 3.4028235e+38f.public static final float MIN_VALUE
float
may represent
is 1.4e-45.public static final float NEGATIVE_INFINITY
public static final float POSITIVE_INFINITY
public static final float NaN
public static final Class TYPE
float
is represented by this
Class
object.public Float(float value)
Float
from the primitive float
specified.value
- the float
argumentpublic Float(double value)
Float
from the primitive double
specified.value
- the double
argumentpublic Float(String s)
Float
from the specified String
.
This method calls Float.parseFloat()
.s
- the String
to convertNumberFormatException
- if s
cannot be parsed as a
float
NullPointerException
- if s
is nullparseFloat(String)
public static String toString(float f)
float
to a String
.
Floating-point string representation is fairly complex: here is a
rundown of the possible values. "[-]
" indicates that a
negative sign will be printed if the value (or exponent) is negative.
"<number>
" means a string of digits ('0' to '9').
"<digit>
" means a single digit ('0' to '9').Value of Float | String Representation |
---|---|
[+-] 0 | [-]0.0 |
Between [+-] 10-3 and 107, exclusive | [-]number.number |
Other numeric value | [-]<digit>.<number>
E[-]<number> |
[+-] infinity | [-]Infinity |
NaN | NaN |
.
and at least one digit printed after
it: even if the number is 3, it will be printed as 3.0
.
After the ".", all digits will be printed except trailing zeros. The
result is rounded to the shortest decimal number which will parse back
to the same float.
To create other output formats, use NumberFormat
.
f
- the float
to convertString
representing the float
public static Float valueOf(String s)
Float
object using the String
.s
- the String
to convertFloat
NumberFormatException
- if s
cannot be parsed as a
float
NullPointerException
- if s
is nullparseFloat(String)
public static float parseFloat(String s)
String
as a float
. The
extended BNF grammar is as follows:DecodableString: ( [-
|+
]NaN
) | ( [-
|+
]Infinity
) | ( [-
|+
] FloatingPoint [f
|F
|d
|D
] ) FloatingPoint: ( { Digit }+ [.
{ Digit } ] [ Exponent ] ) | (.
{ Digit }+ [ Exponent ] ) Exponent: ( (e
|E
) [-
|+
] { Digit }+ ) Digit:'0'
through'9'
NaN and infinity are special cases, to allow parsing of the output of toString. Otherwise, the result is determined by calculating n * 10exponent to infinite precision, then rounding to the nearest float. Remember that many numbers cannot be precisely represented in floating point. In case of overflow, infinity is used, and in case of underflow, signed zero is used. Unlike Integer.parseInt, this does not accept Unicode digits outside the ASCII range.
If an unexpected character is found in the String
, a
NumberFormatException
will be thrown. Leading and trailing
'whitespace' is ignored via String.trim()
, but spaces
internal to the actual number are not allowed.
To parse numbers according to another format, consider using
NumberFormat
.
str
- the String
to convertfloat
value of s
NumberFormatException
- if s
cannot be parsed as a
float
NullPointerException
- if s
is nullMIN_VALUE
,
MAX_VALUE
,
POSITIVE_INFINITY
,
NEGATIVE_INFINITY
public static boolean isNaN(float v)
true
if the float
has the same
value as NaN
, otherwise return false
.v
- the float
to compareNaN
public static boolean isInfinite(float v)
true
if the float
has a value
equal to either NEGATIVE_INFINITY
or
POSITIVE_INFINITY
, otherwise return false
.v
- the float
to comparepublic boolean isNaN()
true
if the value of this Float
is the same as NaN
, otherwise return false
.Float
is NaN
public boolean isInfinite()
true
if the value of this Float
is the same as NEGATIVE_INFINITY
or
POSITIVE_INFINITY
, otherwise return false
.Float
is (-/+) infinitypublic String toString()
float
value of this Float
to a String
. This method calls
Float.toString(float)
to do its dirty work.toString
in class Object
String
representationtoString(float)
public byte byteValue()
Float
as a byte
.public short shortValue()
Float
as a short
.shortValue
in class Number
public int intValue()
Integer
as an int
.public long longValue()
Integer
as a long
.public float floatValue()
Float
.floatValue
in class Number
public double doubleValue()
Float
as a double
doubleValue
in class Number
public int hashCode()
Float
's hash
code is calculated by calling floatToIntBits(floatValue())
.hashCode
in class Object
floatToIntBits(float)
public boolean equals(Object obj)
true
if obj
is an instance of
Float
and represents the same float value. Unlike comparing
two floats with ==
, this treats two instances of
Float.NaN
as equal, but treats 0.0
and
-0.0
as unequal.
Note that f1.equals(f2)
is identical to
floatToIntBits(f1.floatValue()) ==
floatToIntBits(f2.floatValue())
.
public static int floatToIntBits(float value)
Float.intBitsToFloat(int)
to obtain the
original float
value.value
- the float
to convertfloat
intBitsToFloat(int)
public static int floatToRawIntBits(float value)
Float.intBitsToFloat(int)
to
obtain the original float
value.value
- the float
to convertfloat
intBitsToFloat(int)
public static float intBitsToFloat(int bits)
Float.floatToRawIntBits(float)
.bits
- the bits to convertfloat
represented by the bitsfloatToIntBits(float)
,
floatToRawIntBits(float)
public static int compare(float n1, float n2)
n1
- n2
-