模块  java.base
软件包  java.lang

Class Float

  • 实现的所有接口
    SerializableComparable<Float>

    public final class Float
    extends Number
    implements Comparable<Float>
    Float类在对象中包装基本类型float的值。 类型为Float的对象包含单个字段,其类型为float

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

    从以下版本开始:
    1.0
    另请参见:
    Serialized Form
    • 字段汇总

      字段  
      变量和类型 字段 描述
      static int BYTES
      用于表示 float值的字节数。
      static int MAX_EXPONENT
      最大指数有限 float变量可能有。
      static float MAX_VALUE
      保持 float类型的最大正有限值的 float ,(2-2 -23 )·2 127
      static int MIN_EXPONENT
      标准化 float变量的最小指数可能有。
      static float MIN_NORMAL
      保持 float类型的最小正正常值的 float ,2 -126
      static float MIN_VALUE
      保持 float类型的最小正非零值的 float ,2 -149
      static float NaN
      保持 float类型的非数字(NaN)值的 float
      static float NEGATIVE_INFINITY
      持有 float型负无穷大的 float
      static float POSITIVE_INFINITY
      持有 float类型的正无穷大的 float
      static int SIZE
      用于表示 float值的位数。
      static <Float> TYPE
      实例表示基本类型 float
    • 构造方法摘要

      构造方法  
      构造器 描述
      Float​(double value)
      已过时。
      使用此构造函数很少是合适的。
      Float​(float value)
      已过时。
      使用此构造函数很少是合适的。
      Float​(String s)
      已过时。
      使用此构造函数很少是合适的。
    • 方法摘要

      所有方法  静态方法  实例方法 具体的方法 
      变量和类型 方法 描述
      byte byteValue()
      返回此值 Floatbyte的基本收缩转换后。
      static int compare​(float f1, float f2)
      比较两个指定的 float值。
      int compareTo​(Float anotherFloat)
      以数字方式比较两个 Float对象。
      double doubleValue()
      返回此值 Floatdouble一个宽元转换后。
      boolean equals​(Object obj)
      将此对象与指定的对象进行比较。
      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()
      返回 true如果此 Float值是无限大, false否则。
      static boolean isInfinite​(float v)
      返回 true如果指定的数是无限大, false否则。
      boolean isNaN()
      返回 true如果此 Float值是不是非数字(NAN), false否则。
      static boolean isNaN​(float v)
      返回 true如果指定的号码是一个不一个数字(NaN)值, false否则。
      long longValue()
      这个的返回值 Floatlong的基本收缩转换后。
      static float max​(float a, float b)
      返回两个 float值中较大的一个, float调用 Math.max一样
      static float min​(float a, float b)
      返回两个 float值中较小的一个, float调用 Math.min一样
      static float parseFloat​(String s)
      返回由指定的 String表示的值初始化的新 float ,由 valueOfFloat方法执行。
      short shortValue()
      返回此值 Floatshort的基本收缩转换后。
      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对象,其中 float由参数字符串 s表示的 float值。
    • 字段详细信息

      • POSITIVE_INFINITY

        public static final float POSITIVE_INFINITY
        持有float型正无穷大的float 它等于Float.intBitsToFloat(0x7f800000)返回的值。
        另请参见:
        常数字段值
      • NEGATIVE_INFINITY

        public static final float NEGATIVE_INFINITY
        持有float型负无穷大的float 它等于Float.intBitsToFloat(0xff800000)返回的值。
        另请参见:
        常数字段值
      • NaN

        public static final float NaN
        保持float类型的非数字(NaN)值的float 它相当于Float.intBitsToFloat(0x7fc00000)返回的值。
        另请参见:
        常数字段值
      • MAX_VALUE

        public static final float MAX_VALUE
        持有float类型的最大正有限值的float ,(2-2 -23 )·2 127 它等于十六进制浮点文字0x1.fffffeP+127f ,也等于Float.intBitsToFloat(0x7f7fffff)
        另请参见:
        常数字段值
      • MIN_NORMAL

        public static final float MIN_NORMAL
        保持float类型的最小正正常值的float ,2 -126 它等于十六进制浮点文字0x1.0p-126f ,也等于Float.intBitsToFloat(0x00800000)
        从以下版本开始:
        1.6
        另请参见:
        常数字段值
      • MIN_VALUE

        public static final float MIN_VALUE
        保持float类型的最小正非零值的float ,2 -149 它等于十六进制浮点文字0x0.000002P-126f ,也等于Float.intBitsToFloat(0x1)
        另请参见:
        常数字段值
      • 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
        另请参见:
        常数字段值
      • SIZE

        public static final int SIZE
        用于表示 float值的位数。
        从以下版本开始:
        1.5
        另请参见:
        常数字段值
      • BYTES

        public static final int BYTES
        用于表示 float值的字节数。
        从以下版本开始:
        1.8
        另请参见:
        常数字段值
      • TYPE

        public static final <Float> TYPE
        实例表示基本类型 float
        从以下版本开始:
        1.1
    • 构造方法详细信息

      • Float

        @Deprecated(since="9")
        public Float​(float value)
        Deprecated.
        It is rarely appropriate to use this constructor. The static factory valueOf(float) is generally a better choice, as it is likely to yield significantly better space and time performance.
        构造一个新分配的 Float对象,该对象表示原始 float参数。
        参数
        value -值由表示 Float
      • Float

        @Deprecated(since="9")
        public Float​(double value)
        Deprecated.
        It is rarely appropriate to use this constructor. Instead, use the static factory method valueOf(float) method as follows: Float.valueOf((float)value).
        构造一个新分配的 Float对象,该对象表示转换为类型 float的参数。
        参数
        value - 由 Float表示的值。
      • Float

        @Deprecated(since="9")
        public Float​(String s)
              throws NumberFormatException
        Deprecated.
        It is rarely appropriate to use this constructor. Use parseFloat(String) to convert a string to a float primitive, or use valueOf(String) to convert a string to a Float object.
        构造一个新分配的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大于或等于10 -3但小于10 7 ,那么它表示为m的整数部分,以十进制形式表示,没有前导零,后跟' . '( '\u002E' ),后跟一个或多个表示m的小数部分的十进制数字。
          • 如果m小于10 -3或大于或等于10 7 ,则表示为所谓的“计算机化科学记数法”。 n是唯一的整数,使得10N的‰¤ <10 N + 1; 然后让一个m的精确算术商和10 牛顿 ,使1个≤ 一个 <10.然后将大小被表示为a的整数部分,作为一个单一的十进制数字,后跟“ . ”( '\u002E' ),再后面是表示一个小数部分十进制数字,后面跟有字母“ E ”( '\u0045' ),接着为十进制整数n的表示,作为由该方法制备Integer.toString(int)
        ma的小数部分必须打印多少位? 必须至少有一个数字来表示小数部分,并且除此之外必须有多个,但只有多少,更多的数字才能唯一地将参数值与float类型的相邻值区float 也就是说,假设x是由该方法为有限非零参数f生成的十进制表示所表示的精确数学值。 那么f必须是最接近xfloat值; 或者,如果两个float值都同样接近为x,f必须是它们中的一个和f的有效数的至少显著位必须为0

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

        参数
        f - 要转换的浮点数。
        结果
        参数的字符串表示形式。
      • 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"表示。 请注意,在次正规有效数中必须至少有一个非零数字。
        Examples 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
        参数
        f - 要转换的 float
        结果
        参数的十六进制字符串表示形式。
        从以下版本开始:
        1.5
      • valueOf

        public static Float valueOf​(String s)
                             throws NumberFormatException
        返回Float对象,其中float由参数字符串s表示的float值。

        如果snull ,则抛出NullPointerException

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

        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
        其中SignFloatingPointLiteralHexNumeralHexDigitsSignedIntegerFloatTypeSuffixThe Java™ Language Specification的词汇结构部分中定义 ,除了数字之间不接受下划线。 如果s不具有的floatValue的形式,那么NumberFormatException异常。 否则, s被视为代表通常的“计算机化科学记数法”中的精确十进制值或精确的十六进制值; 然后,这个精确的数值在概念上被转换为“无限精确”的二进制值,然后通过IEEE 754浮点运算的通常的舍入到float规则四舍五入到float类型,其中包括保留零值的符号。 请注意,舍入到最近的规则也意味着溢出和下溢行为; 如果s的确切值足够大(大于或等于( MAX_VALUE + ulp(MAX_VALUE)/2 ),则舍入到float将导致无穷大,如果s的确切值足够小(小于或等于)到MIN_VALUE/2 ),舍入到float将导致零。最后,在舍入后,返回表示此float值的Float对象。

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

        请注意,尾随格式说明符,确定浮点文字类型的说明符( 1.0ffloat值; 1.0ddouble值), 不会影响此方法的结果。 换句话说,输入字符串的数值直接转换为目标浮点类型。 通常,两步转换序列,字符串为double后跟doublefloat并不等同于将字符串直接转换为float 例如,如果首先转换为中间double ,然后转换为doublefloat字符串
        "1.00000017881393421514957253748434595763683319091796875001d"
        结果在float1.0000002f ; 如果字符串直接转化为float1.0000001f结果。

        避免调用上无效字符串这种方法和具有NumberFormatException被抛出,该文档Double.valueOf列表正则表达式可用于筛选的输入端。

        参数
        s - 要解析的字符串。
        结果
        一个 Float对象,其中 String参数表示的值。
        异常
        NumberFormatException - 如果字符串不包含可分析的数字。
      • valueOf

        public static Float valueOf​(float f)
        返回表示指定的float值的Float实例。 如果不需要新的Float实例,则通常应优先使用此方法,而不是构造函数Float(float) ,因为此方法可能通过缓存频繁请求的值来显着提高空间和时间性能。
        参数
        f - 浮点值。
        结果
        Float实例,代表 f
        从以下版本开始:
        1.5
      • parseFloat

        public static float parseFloat​(String s)
                                throws NumberFormatException
        返回一个新 float初始化为指定的代表的值 String ,如通过执行 valueOf类的方法 Float
        参数
        s - 要解析的字符串。
        结果
        字符串参数表示的 float值。
        异常
        NullPointerException - 如果字符串为null
        NumberFormatException - 如果字符串不包含可解析的 float
        从以下版本开始:
        1.2
        另请参见:
        valueOf(String)
      • isNaN

        public static boolean isNaN​(float v)
        返回 true如果指定的号码是一个不一个数字(NaN)值, false否则。
        参数
        v - 要测试的值。
        结果
        true如果参数是NaN; 否则为false
      • isInfinite

        public static boolean isInfinite​(float v)
        返回 true如果指定的数是无限大, false否则。
        参数
        v - 要测试的值。
        结果
        true如果参数为正无穷大或负无穷大; 否则为false
      • isFinite

        public static boolean isFinite​(float f)
        如果参数是有限浮点值,则返回true ; 否则返回false (对于NaN和无穷大参数)。
        参数
        f - 要测试的 float
        结果
        true如果参数是有限浮点值, false
        从以下版本开始:
        1.8
      • isNaN

        public boolean isNaN()
        返回 true如果此 Float值是不是非数字(NAN), false否则。
        结果
        true如果此对象表示的值为NaN; 否则为false
      • isInfinite

        public boolean isInfinite()
        返回 true如果此 Float值是无限大, false否则。
        结果
        true如果此对象表示的值为正无穷大或负无穷大; 否则为false
      • toString

        public String toString()
        返回此Float对象的字符串表示形式。 由该对象表示的原始float值被转换为String ,就像通过一个参数的方法toString
        重写:
        toStringObject
        结果
        此对象的 String表示形式。
        另请参见:
        toString(float)
      • byteValue

        public byte byteValue()
        返回此值 Floatbyte的基本收缩转换后。
        重写:
        byteValue ,类 Number
        结果
        此对象表示的 float值已转换为类型 byte
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • shortValue

        public short shortValue()
        返回此值 Floatshort的基本收缩转换后。
        重写:
        shortValue在类 Number
        结果
        此对象表示的 float值转换为类型 short
        从以下版本开始:
        1.1
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • intValue

        public int intValue()
        返回此的值 Float作为 int的基本收缩转换之后。
        Specified by:
        intValue在类 Number
        结果
        此对象表示的 float值转换为类型 int
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • longValue

        public long longValue()
        这个的返回值 Floatlong的基本收缩转换后。
        Specified by:
        longValue ,类 Number
        结果
        此对象表示的 float值转换为类型 long
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • floatValue

        public float floatValue()
        返回此 Float对象的 float值。
        Specified by:
        floatValueNumber类中
        结果
        此对象表示的 float
      • doubleValue

        public double doubleValue()
        返回此值 Floatdouble一个宽元转换后。
        Specified by:
        doubleValueNumber
        结果
        此对象表示的 float值转换为类型 double
        See The Java™ Language Specification:
        5.1.2拓宽原始转换
      • 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值相同。

        请注意,在大多数情况下,类的两个实例Floatf1f2 ,价值f1.equals(f2)true当且仅当

           f1.floatValue() == f2.floatValue()
         

        也有true的价值。 但是,有两个例外:

        • 如果f1f2均表示Float.NaN ,则equals方法返回true ,即使Float.NaN==Float.NaN的值为false
        • 如果f1代表+0.0ff2代表-0.0f ,反之亦然, equal测试的值为false ,即使0.0f==-0.0f的值为true
        此定义允许哈希表正常运行。
        重写:
        equalsObject
        参数
        obj - 要比较的对象
        结果
        true如果对象相同; 否则为false
        另请参见:
        floatToIntBits(float)
      • floatToIntBits

        public static int floatToIntBits​(float value)
        根据IEEE 754浮点“单一格式”位布局返回指定浮点值的表示形式。

        位31(掩码0x80000000选择的位)表示浮点数的符号。 位30-23(由掩码0x7f800000选择的位)表示指数。 比特22-0(由掩码0x007fffff选择的比特)表示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选择的比特)表示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 ,则结果为负无穷大。

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

        在所有其他情况下,让sem为可以从参数计算的三个值:

        
         int s = ((bits >> 31) == 0) ? 1 : -1;
         int e = ((bits >> 23) & 0xff);
         int m = (e == 0) ?
                         (bits & 0x7fffff) << 1 :
                         (bits & 0x7fffff) | 0x800000;
         
        然后浮点结果等于数学表达式值· m ·2 e -150

        请注意,此方法可能无法返回具有与int参数完全相同的位模式的float NaN。 IEEE 754区分了两种NaN,即安静的NaN和信号NaN 两种NaN之间的差异通常在Java中不可见。 对信令NaN的算术运算将它们转换为具有不同但通常类似的位模式的安静NaN。 然而,在一些处理器上,仅复制信令NaN也执行该转换。 特别地,复制信令NaN以将其返回到调用方法可以执行该转换。 因此, intBitsToFloat可能无法返回具有信令NaN位模式的float 因此,对于一些intfloatToRawIntBits(intBitsToFloat(start))可能等于start 此外,哪些特定位模式表示信令NaN是平台相关的; 虽然所有NaN位模式,安静或信令,必须在上面确定的NaN范围内。

        参数
        bits - 一个整数。
        结果
        具有相同位模式的 float浮点值。
      • compareTo

        public int compareTo​(Float anotherFloat)
        以数字方式比较两个Float对象。 当应用于原始float值时,此方法执行的比较有两种方式与Java语言数值比较运算符( <, <=, ==, >=, > )执行的比较不同:
        • 通过此方法认为Float.NaN等于其自身并且大于所有其他float值(包括Float.POSITIVE_INFINITY )。
        • 0.0f通过该方法被认为是大于-0.0f
        这确保了此方法强加的Float对象的自然排序 与equals一致
        Specified by:
        compareTo ,界面 Comparable<Float>
        参数
        anotherFloat - 待比较的 Float
        结果
        0如果anotherFloat在数值上等于此Float ; 的值小于0 ,如果这Float是数值上小于anotherFloat ; 和大于一个值0如果此Float在数值上大于anotherFloat
        从以下版本开始:
        1.2
        另请参见:
        Comparable.compareTo(Object)
      • compare

        public static int compare​(float f1,
                                  float f2)
        比较两个指定的float值。 返回的整数值的符号与调用返回的整数的符号相同:
          new Float(f1).compareTo(new Float(f2)) 
        参数
        f1 - 第一个 float进行比较。
        f2 - 第二个 float进行比较。
        结果
        0如果f1在数值上等于f2 ; 的值小于0如果f1是数值上小于f2 ; 且大于值0如果f1在数值上大于f2
        从以下版本开始:
        1.4
      • sum

        public static float sum​(float a,
                                float b)
        根据+运算符一起添加两个 float值。
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        总和 ab
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator
        See The Java™ Language Specification:
        4.2.4浮点运算
      • max

        public static float max​(float a,
                                float b)
        返回两个 float值中较大的一个, float调用 Math.max一样
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        ab的较大者
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator
      • min

        public static float min​(float a,
                                float b)
        返回两个 float值中较小的一个, float调用 Math.min一样
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        较小的 ab
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator