模块 java.base

包 java.lang

类 Float

java.lang.Object

java.lang.Number

java.lang.Float

所有已实现的接口：

Serializable , Comparable<Float> , Constable , ConstantDesc

public final class Float extends Number implements Comparable <Float >, Constable , ConstantDesc 
      

Float 类将原始类型 float 的值包装在一个对象中。 Float 类型的对象包含一个类型为 float 的字段。

此外，此类提供了几种将 float 转换为 String 和将 String 转换为 float 的方法，以及处理 float 时有用的其他常量和方法。

这是一个value-based类；程序员应该将 equal 的实例视为可互换的，并且不应使用实例进行同步，否则可能会发生不可预测的行为。例如，在未来的版本中，同步可能会失败。

浮点相等、等价和比较

类 java.lang.Double 有一个 浮点值的相等、等价和比较的讨论 同样适用于 float 值。

自从：

1.0

参见：

• IEEE 浮点运算标准
• Serialized Form

字段摘要

字段

修饰符和类型	Field	描述
static final int	BYTES	用于表示 float 值的字节数。
static final int	MAX_EXPONENT	有限 float 变量可能具有的最大指数。
static final float	MAX_VALUE	一个常量，保持 float 类型的最大正有限值，(2-2-23)·2127.
static final int	MIN_EXPONENT	标准化 float 变量可能具有的最小指数。
static final float	MIN_NORMAL	保持类型 float 的最小正正常值的常量，2-126.
static final float	MIN_VALUE	保持类型 float 的最小正非零值的常量，2-149.
static final float	NaN	一个常量，包含 float 类型的非数字 (NaN) 值。
static final float	NEGATIVE_INFINITY	一个保持 float 类型的负无穷大的常量。
static final float	POSITIVE_INFINITY	一个保持类型为 float 的正无穷大的常量。
static final int	PRECISION	float 值的有效位数中的位数。
static final int	SIZE	用于表示 float 值的位数。
static final Class<Float>	TYPE	代表原始类型 float 的 Class 实例。

构造方法总结

构造方法

构造方法	描述
Float(double value)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 使用此构造方法很少是合适的。
Float(float value)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 使用此构造方法很少是合适的。
Float(String s)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 使用此构造方法很少是合适的。

方法总结

修饰符和类型	方法	描述
byte	byteValue()	在缩小基元转换后将此 Float 的值作为 byte 返回。
static int	compare(float f1, float f2)	比较两个指定的 float 值。
int	compareTo(Float anotherFloat)	比较两个 Float 对象的数值。
Optional<Float>	describeConstable()	返回一个 Optional ，其中包含此实例的标称描述符，即实例本身。
double	doubleValue()	在扩展原始转换后将此 Float 的值作为 double 返回。
boolean	equals(Object obj)	将此对象与指定对象进行比较。
static float	float16ToFloat(short floatBinary16)	返回最接近参数数值的 float 值，一个在 short 中编码的浮点二进制 16 值。
static short	floatToFloat16(float f)	返回浮点 binary16 值，编码在 short 中，值最接近参数。
static int	floatToIntBits(float value)	根据 IEEE 754 浮点“单一格式”位布局返回指定浮点值的表示形式。
static int	floatToRawIntBits(float value)	根据 IEEE 754 浮点“单一格式”位布局返回指定浮点值的表示形式，保留非数字 (NaN) 值。
float	floatValue()	返回此 Float 对象的 float 值。
int	hashCode()	返回此 Float 对象的哈希码。
static int	hashCode(float value)	返回 float 值的哈希码；与 Float.hashCode() 兼容。
static float	intBitsToFloat(int bits)	返回对应于给定位表示的 float 值。
int	intValue()	在缩小基元转换后将此 Float 的值作为 int 返回。
static boolean	isFinite(float f)	如果参数是有限浮点值，则返回 true；否则返回 false（对于 NaN 和无穷大参数）。
boolean	isInfinite()	如果此 Float 值的大小无限大，则返回 true，否则返回 false。
static boolean	isInfinite(float v)	如果指定数的数量级无限大，则返回 true，否则返回 false。
boolean	isNaN()	如果此 Float 值是非数字 (NaN)，则返回 true，否则返回 false。
static boolean	isNaN(float v)	如果指定的数字是非数字 (NaN) 值，则返回 true，否则返回 false。
long	longValue()	在缩小基元转换后将此 Float 的值作为 long 返回。
static float	max(float a, float b)	返回两个 float 值中较大的一个，就像调用 Math.max 一样。
static float	min(float a, float b)	返回两个 float 值中较小的一个，就像调用 Math.min 一样。
static float	parseFloat(String s)	返回一个新的 float 初始化为由指定的 String 表示的值，由类 Float 的 valueOf 方法执行。
Float	resolveConstantDesc(MethodHandles.Lookup lookup)	将此实例解析为 ConstantDesc ，其结果是实例本身。
short	shortValue()	在缩小基元转换后将此 Float 的值作为 short 返回。
static float	sum(float a, float b)	根据 + 运算符将两个 float 值相加。
static String	toHexString(float f)	返回 float 参数的十六进制字符串表示形式。
String	toString()	返回此 Float 对象的字符串表示形式。
static String	toString(float f)	返回 float 参数的字符串表示形式。
static Float	valueOf(float f)	返回代表指定 float 值的 Float 实例。
static Float	valueOf(String s)	返回一个 Float 对象，其中包含由参数字符串 s 表示的 float 值。

在类 java.lang.Object 中声明的方法

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

字段详细信息

POSITIVE_INFINITY

public static final float POSITIVE_INFINITY
            

一个保持类型为 float 的正无穷大的常量。它等于 Float.intBitsToFloat(0x7f800000) 返回的值。

参见：

• 常量字段值

NEGATIVE_INFINITY

public static final float NEGATIVE_INFINITY
            

一个保持 float 类型的负无穷大的常量。它等于 Float.intBitsToFloat(0xff800000) 返回的值。

参见：

• 常量字段值

NaN

public static final float NaN
            

一个常量，包含 float 类型的非数字 (NaN) 值。它相当于 Float.intBitsToFloat(0x7fc00000) 返回的值。

参见：

• 常量字段值

MAX_VALUE

public static final float MAX_VALUE
            

一个常量，保持 float 类型的最大正有限值，(2-2^-23)·2¹²⁷.它等于十六进制浮点文字 0x1.fffffeP+127f 也等于 Float.intBitsToFloat(0x7f7fffff) 。

参见：

• 常量字段值

MIN_NORMAL

public static final float MIN_NORMAL
            

保持类型 float 的最小正正常值的常量，2^-126.它等于十六进制浮点文字 0x1.0p-126f 也等于 Float.intBitsToFloat(0x00800000) 。

自从：

1.6

参见：

• 常量字段值

MIN_VALUE

public static final float MIN_VALUE
            

保持类型 float 的最小正非零值的常量，2^-149.它等于十六进制浮点文字 0x0.000002P-126f 也等于 Float.intBitsToFloat(0x1) 。

参见：

• 常量字段值

SIZE

public static final int SIZE
            

用于表示 float 值的位数。

自从：

1.5

参见：

• 常量字段值

PRECISION

public static final int PRECISION
            

float 值的有效位数中的位数。这是 4.2.3 节中的参数 NJava 语言规范.

自从：

19

参见：

• 常量字段值

MAX_EXPONENT

public static final int MAX_EXPONENT
            

有限 float 变量可能具有的最大指数。它等于 Math.getExponent(Float.MAX_VALUE) 返回的值。

自从：

1.6

参见：

• 常量字段值

MIN_EXPONENT

public static final int MIN_EXPONENT
            

标准化 float 变量可能具有的最小指数。它等于 Math.getExponent(Float.MIN_NORMAL) 返回的值。

自从：

1.6

参见：

• 常量字段值

BYTES

public static final int BYTES
            

用于表示 float 值的字节数。

自从：

1.8

参见：

• 常量字段值

TYPE

public static final Class <Float > TYPE
            

代表原始类型 float 的 Class 实例。

自从：

1.1

构造方法详细信息

Float

@Deprecated (since ="9", forRemoval =true) public Float(float value)
            

已弃用，将被删除：此 API 元素可能会在未来版本中删除。

使用此构造函数很少是合适的。静态工厂 valueOf(float) 通常是更好的选择，因为它可能会产生更好的空间和时间性能。

构造一个新分配的 Float 对象，表示原始 float 参数。

参数：

value - 由 Float 表示的值。

Float

@Deprecated (since ="9", forRemoval =true) public Float(double value)
            

已弃用，将被删除：此 API 元素可能会在未来版本中删除。

使用此构造函数很少是合适的。相反，使用静态工厂方法 valueOf(float) 方法如下： Float.valueOf((float)value) 。

构造一个新分配的 Float 对象，表示转换为类型 float 的参数。

参数：

value - 由 Float 表示的值。

Float

@Deprecated (since ="9", forRemoval =true) public Float(String  s) throws NumberFormatException 
            

已弃用，将被删除：此 API 元素可能会在未来版本中删除。

使用此构造函数很少是合适的。使用 parseFloat(String) 将字符串转换为 float 基元，或使用 valueOf(String) 将字符串转换为 Float 对象。

构造一个新分配的 Float 对象，该对象表示由字符串表示的 float 类型的浮点值。字符串被转换为 float 值，就像通过 valueOf 方法一样。

参数：

s - 要转换为 Float 的字符串。

抛出：

NumberFormatException - 如果字符串不包含可解析的数字。

方法详情

toString

public static String  toString(float f)
            

返回 float 参数的字符串表示形式。下面提到的所有字符都是 ASCII 字符。

• 如果参数为 NaN，则结果为字符串“NaN”。
• 否则，结果是表示参数的符号和大小（绝对值）的字符串。如果符号为负，则结果的第一个字符为'-'('\u002D')；如果符号为正，则结果中不出现符号字符。至于量级m:
  • 如果m是无穷大，用字符 "Infinity" 表示；因此，正无穷大产生结果 "Infinity" ，负无穷大产生结果 "-Infinity" 。
  • 如果m为零，由字符 "0.0" 表示；因此，负零产生结果 "-0.0"，正零产生结果 "0.0"。
  • 否则m是积极的和有限的。它分两个阶段转换为字符串：
    • Selection of a decimal：定义明确的小数d_m被选中代表m.这个小数（几乎总是）四舍五入到的 shortestm根据 IEEE 754 浮点算法的舍入到最近舍入策略。
    • Formatting as a string：十进制d_m被格式化为一个字符串，可以是普通的，也可以是计算机化的科学记数法，这取决于它的值。

A decimal 是形式的数字s×10ⁱ对于一些（唯一的）整数s> 0 和i这样s不是 10 的倍数。这些整数分别是小数的 significand 和 exponent 。小数的length是（唯一的）正整数n会议 10^n-1≤s < 10ⁿ.

小数点d_m对于有限正数m定义如下：

• 让R是舍入到的所有小数的集合m根据 IEEE 754 浮点运算的通常 round to nearest 舍入策略。
• 让p是所有小数的最小长度R.
• 什么时候p≥ 2, 让T是所有小数的集合R有长度p.否则，让T是所有小数的集合R长度为 1 或 2。
• 定义d_m作为小数点T这是最接近m.或者如果有两个这样的小数T选择具有偶数尾数的那个。

（唯一）选定的小数d_m然后被格式化。让s, i和n是有效数，指数和长度d_m， 分别。进一步，让e = n + i1 让s₁……s_n是通常的十进制扩展s.注意s₁≠ 0 和s_n≠ 0。下面，小数点'.'为'\u002E'，指数指标'E'为'\u0045'。

• 情况-3≤e < 0: d_m格式为 0.0 …0s₁……s_n, 其中恰好有 -(n + i) 小数点和之间的零s₁.例如，123×10^-4格式为 0.0123 。
• 情况 0 ≤e < 7:
  • 子案例i≥ 0:d_m格式为s₁……s_n0 …0.0 ，那里正好有i之间的零s_n和小数点。例如，123×10²格式为 12300.0 。
  • 子案例i < 0: d_m格式为s₁……s_n+i. s_n+i+1……s_n，其中恰好有 -i小数点右边的数字。例如，123×10^-1格式为 12.3 。
• 案件e< -3 或e≥7：采用计算机科学记数法进行格式化d_m.这里e格式为 Integer.toString(int) 。
  • 子案例n = 1: d_m格式为s₁.0E e.例如，1 × 10²³格式为 1.0E23 。
  • 子案例n > 1: d_m格式为s₁. s₂……s_nE e.例如，123×10^-21格式为 1.23E-19 。

要创建浮点值的本地化字符串表示，请使用 NumberFormat 的子类。

参数：

f - 要转换的 float。

返回：

参数的字符串表示。

toHexString

public static String  toHexString(float f)
            

返回 float 参数的十六进制字符串表示形式。下面提到的所有字符都是 ASCII 字符。

• 如果参数为 NaN，则结果为字符串“NaN”。
• 否则，结果是表示参数的符号和大小（绝对值）的字符串。如果符号为负，则结果的第一个字符为'-'('\u002D')；如果符号为正，则结果中不出现符号字符。至于量级m:
  • 如果m是无穷大，它由字符串 "Infinity" 表示；因此，正无穷大产生结果 "Infinity" ，负无穷大产生结果 "-Infinity" 。
  • 如果m为零，由字符串 "0x0.0p0" 表示；因此，负零产生结果 "-0x0.0p0"，正零产生结果 "0x0.0p0"。
  • 如果m是具有规范化表示的 float 值，子字符串用于表示有效数字和指数字段。有效数字由字符 "0x1." 表示，后跟有效数字其余部分的小写十六进制表示形式作为分数。十六进制表示中的尾随零被删除，除非所有数字都是零，在这种情况下使用单个零。接下来，指数由 "p" 表示，后跟无偏指数的十进制字符串，就好像通过对指数值调用 Integer.toString 产生的一样。
  • 如果m是具有次正规表示的 float 值，有效数由字符 "0x0." 表示，后跟有效数的其余部分的十六进制表示形式作为分数。十六进制表示中的尾随零被删除。接下来，指数由 "p-126" 表示。请注意，次正规尾数中必须至少有一个非零数字。

示例

浮点值	十六进制字符串
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

参数：

f - 要转换的 float。

返回：

参数的十六进制字符串表示。

自从：

1.5

valueOf

public static Float  valueOf(String  s) throws NumberFormatException 
            

返回一个 Float 对象，其中包含由参数字符串 s 表示的 float 值。

如果 s 是 null，则抛出 NullPointerException。

s 中的前导和尾随空白字符将被忽略。如同使用 String.trim() 方法一样删除空格；也就是说，ASCII 空格和控制字符都被删除了。 s 的其余部分应该构成一个FloatValue如词法语法规则所述：

浮动值：

符号_选择 NaN

符号_选择 Infinity

符号_选择 FloatingPointLiteral

符号_选择 HexFloatingPointLiteral

SignedInteger

HexFloatingPointLiteral:

HexSignificand BinaryExponent FloatTypeSuffix_选择

十六进制有效数：

HexNumeral

HexNumeral .

0x HexDigits_选择 . HexDigits

0X HexDigits_选择 . HexDigits

二进制指数：

BinaryExponentIndicator 有符号整数

二进制指数指标：

p

P

在哪里符号, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger和FloatTypeSuffix是在词法结构部分中定义的Java 语言规范, 除了数字之间不接受下划线。如果 s 没有 a 的形式FloatValue然后抛出一个 NumberFormatException 。否则，s 被视为表示通常的“计算机科学计数法”中的精确十进制值或精确的十六进制值；然后，这个精确的数值在概念上被转换为“无限精确”的二进制值，然后通过 IEEE 754 浮点算法的常用舍入到最近规则舍入为类型 float，其中包括保留零值的符号。请注意，舍入到最近的规则也意味着溢出和下溢行为；如果 s 的精确值足够大（大于或等于 (MAX_VALUE + ulp(MAX_VALUE) /2），则四舍五入到 float 将导致无穷大，如果 s 的精确值足够小（小于或等于到 MIN_VALUE /2)，四舍五入为浮点数将导致零。最后，在四舍五入后返回表示此 float 值的 Float 对象。

要解释浮点值的本地化字符串表示，请使用 NumberFormat 的子类。

请注意，尾随格式说明符、确定浮点文字类型的说明符（1.0f 是一个 float 值；1.0d 是一个 double 值）确实会影响此方法的结果。换句话说，输入字符串的数值直接转换为目标浮点类型。一般来说，两步转换序列，字符串到 double，然后是 double 到 float，not 等同于将字符串直接转换为 float。例如，如果首先转换为中间 double 然后转换为 float，则字符串
"1.00000017881393421514957253748434595763683319091796875001d"
结果 float 值 1.0000002f ；如果字符串直接转换为 float ， 1.0000001f 结果。

为避免在无效字符串上调用此方法并抛出 NumberFormatException，Double.valueOf 的文档列出了可用于筛选输入的正则表达式。

参数：

s - 要解析的字符串。

返回：

一个 Float 对象保存由 String 参数表示的值。

抛出：

NumberFormatException - 如果字符串不包含可解析的数字。

valueOf

public static Float  valueOf(float f)
            

返回代表指定 float 值的 Float 实例。如果不需要新的 Float 实例，则通常应优先使用此方法而不是构造函数 Float(float) ，因为此方法可能会通过缓存频繁请求的值来产生明显更好的空间和时间性能。

参数：

f - 浮点值。

返回：

代表 f 的 Float 实例。

自从：

1.5

parseFloat

public static float parseFloat(String  s) throws NumberFormatException 
            

返回一个新的 float 初始化为由指定的 String 表示的值，由类 Float 的 valueOf 方法执行。

参数：

s - 要解析的字符串。

返回：

字符串参数表示的 float 值。

抛出：

NullPointerException - 如果字符串为空

NumberFormatException - 如果字符串不包含可解析的 float 。

自从：

1.2

参见：

• valueOf(String)

isNaN

public static boolean isNaN(float v)
            

如果指定的数字是非数字 (NaN) 值，则返回 true，否则返回 false。

API 注意：

此方法对应于 IEEE 754 中定义的 isNaN 操作。

参数：

v - 要测试的值。

返回：

true 如果参数是 NaN； false否则。

isInfinite

public static boolean isInfinite(float v)
            

如果指定数的数量级无限大，则返回 true，否则返回 false。

API 注意：

此方法对应于 IEEE 754 中定义的 isInfinite 操作。

参数：

v - 要测试的值。

返回：

true 如果参数是正无穷大或负无穷大； false否则。

isFinite

public static boolean isFinite(float f)
            

如果参数是有限浮点值，则返回 true；否则返回 false（对于 NaN 和无穷大参数）。

API 注意：

此方法对应于 IEEE 754 中定义的 isFinite 操作。

参数：

f - 要测试的 float 值

返回：

true 如果参数是有限浮点值，false 否则。

自从：

1.8

isNaN

public boolean isNaN()
            

如果此 Float 值是非数字 (NaN)，则返回 true，否则返回 false。

返回：

true如果这个对象表示的值是NaN； false否则。

isInfinite

public boolean isInfinite()
            

如果此 Float 值的大小无限大，则返回 true，否则返回 false。

返回：

true 如果此对象表示的值是正无穷大或负无穷大； false否则。

toString

public String  toString()
            

返回此 Float 对象的字符串表示形式。此对象表示的原始 float 值被转换为 String 就像通过一个参数的方法 toString 一样。

重写：

toString 在类 Object 中

返回：

此对象的 String 表示。

参见：

• toString(float)

byteValue

public byte byteValue()
            

在缩小基元转换后将此 Float 的值作为 byte 返回。

重写：

byteValue 在类 Number 中

返回：

此对象表示的 float 值转换为类型 byte

看Java 语言规范:

5.1.3 缩小原始转换

shortValue

public short shortValue()
            

在缩小基元转换后将此 Float 的值作为 short 返回。

重写：

shortValue 在类 Number 中

返回：

此对象表示的 float 值转换为类型 short

看Java 语言规范:

5.1.3 缩小原始转换

自从：

1.1

intValue

public int intValue()
            

在缩小基元转换后将此 Float 的值作为 int 返回。

指定者：

intValue 在类 Number 中

返回：

此对象表示的 float 值转换为类型 int

看Java 语言规范:

5.1.3 缩小原始转换

longValue

public long longValue()
            

在缩小基元转换后将此 Float 的值作为 long 返回。

指定者：

longValue 在类 Number 中

返回：

此对象表示的 float 值转换为类型 long

看Java 语言规范:

5.1.3 缩小原始转换

floatValue

public float floatValue()
            

返回此 Float 对象的 float 值。

指定者：

floatValue 在类 Number 中

返回：

此对象表示的 float 值

doubleValue

public double doubleValue()
            

在扩展原始转换后将此 Float 的值作为 double 返回。

指定者：

doubleValue 在类 Number 中

API 注意：

此方法对应于 IEEE 754 中定义的 convertFormat 操作。

返回：

此对象表示的 float 值转换为类型 double

看Java 语言规范:

5.1.2 拓宽原始转换

hashCode

public int hashCode()
            

返回此 Float 对象的哈希码。结果是此 Float 对象表示的原始 float 值的整数位表示，与方法 floatToIntBits(float) 生成的完全相同。

重写：

hashCode 在类 Object 中

返回：

此对象的哈希码值。

参见：

• Object.equals(java.lang.Object)
• System.identityHashCode(java.lang.Object)

hashCode

public static int hashCode(float value)
            

返回 float 值的哈希码；与 Float.hashCode() 兼容。

参数：

value - 要散列的值

返回：

float 值的哈希码值。

自从：

1.8

equals

public boolean equals(Object  obj)
            

将此对象与指定对象进行比较。结果是 true 当且仅当参数不是 null 并且是一个 Float 对象表示一个 float 与该对象表示的 float 具有相同的值。为此，当且仅当方法 floatToIntBits(float) 在应用于每个时返回相同的 int 值时，两个 float 值被认为是相同的。

重写：

equals 在类 Object 中

API 注意：

此方法是根据 floatToIntBits(float) 而不是 float 值上的 == 运算符定义的，因为 == 运算符确实 not 定义了等价关系，并且为了满足 等于合同 必须实现等价关系；有关浮点相等和等价的详细信息，请参阅 这个讨论。

参数：

obj - 要比较的对象

返回：

true 如果对象相同； false否则。

看Java 语言规范:

15.21.1 数值相等运算符 == 和 !=

参见：

• floatToIntBits(float)

floatToIntBits

public static int floatToIntBits(float value)
            

根据 IEEE 754 浮点“单一格式”位布局返回指定浮点值的表示形式。

第 31 位（由掩码 0x80000000 选择的位）表示浮点数的符号。位 30-23（由掩码 0x7f800000 选择的位）表示指数。位 22-0（由掩码 0x007fffff 选择的位）表示浮点数的有效数字（有时称为尾数）。

如果参数为正无穷大，则结果为 0x7f800000 。

如果参数为负无穷大，则结果为 0xff800000 。

如果参数为 NaN，则结果为 0x7fc00000 。

在所有情况下，结果都是一个整数，当将其提供给 intBitsToFloat(int) 方法时，将生成与 floatToIntBits 的参数相同的浮点值（除了所有 NaN 值都折叠为单个“规范”NaN 值）。

参数：

value - 浮点数。

返回：

表示浮点数的位。

floatToRawIntBits

public static int floatToRawIntBits(float value)
            

根据 IEEE 754 浮点“单一格式”位布局返回指定浮点值的表示形式，保留非数字 (NaN) 值。

第 31 位（由掩码 0x80000000 选择的位）表示浮点数的符号。位 30-23（由掩码 0x7f800000 选择的位）表示指数。位 22-0（由掩码 0x007fffff 选择的位）表示浮点数的有效数字（有时称为尾数）。

如果参数为正无穷大，则结果为 0x7f800000 。

如果参数为负无穷大，则结果为 0xff800000 。

如果参数是 NaN，则结果是表示实际 NaN 值的整数。与 floatToIntBits 方法不同，floatToRawIntBits 不会将编码 NaN 的所有位模式折叠为单个“规范”NaN 值。

在所有情况下，结果都是一个整数，当将其提供给 intBitsToFloat(int) 方法时，将生成与 floatToRawIntBits 的参数相同的浮点值。

参数：

value - 浮点数。

返回：

表示浮点数的位。

自从：

1.3

intBitsToFloat

public static float intBitsToFloat(int bits)
            

返回对应于给定位表示的 float 值。根据 IEEE 754 浮点“单一格式”位布局，该参数被认为是浮点值的表示。

如果参数为 0x7f800000 ，则结果为正无穷大。

如果参数为 0xff800000 ，则结果为负无穷大。

如果参数是 0x7f800001 到 0x7fffffff 范围内或 0xff800001 到 0xffffffff 范围内的任何值，则结果为 NaN。 Java 提供的 IEEE 754 浮点运算无法区分具有不同位模式的相同类型的两个 NaN 值。 NaN 的不同值只能通过使用 Float.floatToRawIntBits 方法来区分。

在所有其他情况下，令s, e， 和m是可以从参数计算的三个值：

int s = ((bits >> 31) == 0) ? 1 : -1;
int e = ((bits >> 23) & 0xff);
int m = (e == 0) ?
        (bits & 0x7fffff) << 1 :
        (bits & 0x7fffff) | 0x800000;
 

那么浮点结果等于数学表达式的值s·m·2^e-150.

请注意，此方法可能无法返回位模式与 int 参数完全相同的 float NaN。 IEEE 754 区分两种 NaN，安静 NaN 和信号 NaN.这两种 NaN 之间的差异在 Java 中通常是看不出来的。对信号 NaN 的算术运算将它们变成具有不同但通常相似的位模式的安静 NaN。但是，在某些处理器上，仅复制信令 NaN 也会执行该转换。特别是，复制信号 NaN 以将其返回给调用方法可能会执行此转换。因此 intBitsToFloat 可能无法返回带有信令 NaN 位模式的 float。因此，对于某些 int 值，floatToRawIntBits(intBitsToFloat(start)) 可能not等于 start 。此外，哪些特定的位模式表示信号 NaN 是平台相关的；尽管所有 NaN 位模式，安静或信号，都必须在上面标识的 NaN 范围内。

参数：

bits - 一个整数。

返回：

float 具有相同位模式的浮点值。

float16ToFloat

public static float float16ToFloat(short floatBinary16)
            

返回最接近参数数值的 float 值，一个在 short 中编码的浮点二进制 16 值。转换是准确的；所有 binary16 值都可以在 float 中准确表示。特别案例：

• 如果参数为零，则结果为与参数符号相同的零。
• 如果参数是无穷大，则结果是与参数同号的无穷大。
• 如果参数为 NaN，则结果为 NaN。

IEEE 754 二进制 16 格式

IEEE 754 标准将 binary16 定义为 16 位格式，以及 32 位 binary32 格式（对应 float 类型）和 64 位 binary64 格式（对应 double 类型）。 binary16 格式类似于其他 IEEE 754 格式，除了更小，具有所有常见的 IEEE 754 值，例如 NaN、有符号无穷大、有符号零和次正规。二进制 16 格式的参数 (JLS4.2.3) 是 N = 11 个精度位，K = 5 个指数位，E_max= 15，和E_min = -14.

API 注意：

该方法对应IEEE 754中定义的从binary16格式到binary32格式的convertFormat操作。此方法的操作类似于原始扩展转换 (JLS 5.1.2)。

参数：

floatBinary16 - 要转换为 float 的二进制 16 值

返回：

最接近参数数值的 float 值，在 short 中编码的浮点二进制 16 值

自从：

20

floatToFloat16

public static short floatToFloat16(float f)
            

返回浮点 binary16 值，编码在 short 中，值最接近参数。转换是在 四舍五入到最接近的偶数舍入模式 下计算的。特别案例：

• 如果参数为零，则结果为与参数符号相同的零。
• 如果参数是无穷大，则结果是与参数同号的无穷大。
• 如果参数为 NaN，则结果为 NaN。

二进制16格式 在 float16ToFloat(short) 方法中有更详细的讨论。

API 注意：

该方法对应IEEE 754中定义的从binary32格式到binary16格式的convertFormat操作。此方法的操作类似于原始收缩转换 (JLS 5.1.3)。

参数：

f - 要转换为 binary16 的 float 值

返回：

浮点 binary16 值，编码在 short 中，最接近参数的值

自从：

20

compareTo

public int compareTo(Float  anotherFloat)
            

比较两个 Float 对象的数值。与 Java 语言数值比较运算符 (<, <=, ==, >=, >) 对 float 值定义的不完整顺序相比，此方法对 Float 对象施加总顺序，有两个不同之处。

• NaN 相对于其他值是 unordered，并且在比较运算符下不等于自身。此方法选择将 Float.NaN 定义为等于自身并大于所有其他 double 值（包括 Float.POSITIVE_INFINITY ）。
• 正零和负零在数值上比较相等，但它们是不同且可区分的值。此方法选择将正零 (+0.0f) 定义为大于负零 (-0.0f)。

这确保了自然排序此方法强加的 Float 个对象是一致;有关浮点比较和排序的详细信息，请参阅 这个讨论。

指定者：

compareTo 在接口 Comparable<Float> 中

参数：

anotherFloat - 要比较的 Float。

返回：

值 0 如果 anotherFloat 在数值上等于此 Float ；如果此 Float 在数值上小于 anotherFloat，则该值小于 0；如果此 Float 在数值上大于 anotherFloat，则该值大于 0。

看Java 语言规范:

15.20.1 数值比较运算符 <、<=、> 和 >=

自从：

1.2

compare

public static int compare(float f1, float f2)
            

比较两个指定的 float 值。返回的整数值的符号与调用返回的整数的符号相同：

  Float.valueOf(f1).compareTo(Float.valueOf(f2))
 

参数：

f1 - 第一个要比较的 float。

f2 - 要比较的第二个 float。

返回：

值 0 如果 f1 在数值上等于 f2 ；如果 f1 在数值上小于 f2 则小于 0 的值；如果 f1 在数值上大于 f2，则值大于 0。

自从：

1.4

sum

public static float sum(float a, float b)
            

根据 + 运算符将两个 float 值相加。

API 注意：

此方法对应于 IEEE 754 中定义的加法运算。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a 和 b 的总和

看Java 语言规范:

4.2.4 浮点运算

自从：

1.8

参见：

• BinaryOperator

max

public static float max(float a, float b)
            

返回两个 float 值中较大的一个，就像调用 Math.max 一样。

API 注意：

此方法对应于 IEEE 754 中定义的最大操作。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a 和 b 中的较大者

自从：

1.8

参见：

• BinaryOperator

min

public static float min(float a, float b)
            

返回两个 float 值中较小的一个，就像调用 Math.min 一样。

API 注意：

此方法对应于 IEEE 754 中定义的最小操作。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a 和 b 中较小的一个

自从：

1.8

参见：

• BinaryOperator

describeConstable

public Optional <Float > describeConstable()
            

返回一个 Optional ，其中包含此实例的标称描述符，即实例本身。

指定者：

describeConstable 在接口 Constable 中

返回：

Optional 描述了 Float 实例

自从：

12

resolveConstantDesc

public Float  resolveConstantDesc(MethodHandles.Lookup  lookup)
            

将此实例解析为 ConstantDesc ，其结果是实例本身。

指定者：

resolveConstantDesc 在接口 ConstantDesc 中

参数：

lookup - 忽略

返回：

Float 实例

自从：

12