java.lang.float_Java中的Java.Lang.Float类 - Break易站

Java 包装类

Java中的Java.Lang.Float类

Float类是原始类型float的包装类，它包含若干有效处理浮点值的方法，如将其转换为字符串表示形式，反之亦然。Float类的一个对象可以包含一个浮点值。主要有两个构造函数来初始化Float对象 -

Float(float b)：创建一个使用提供的值初始化的Float对象。

语法： public Float(Float d)

参数：

d：用于初始化的值

Float(String s)：用字符串表示形式提供的解析浮点值创建一个Float对象。Defalut radix被认为是10。

语法： public Float(String s)

抛出NumberFormatException

参数：

s：字节值的字符串表示

抛出：

NumberFormatException：如果提供的字符串不表示任何浮点值。

方法：

toString()：返回对应于float值的字符串。

语法：public String toString(float b)

参数：

b：需要字符串表示的float值。

valueOf()：返回用提供的值初始化的Float对象。

语法： public static Float valueOf(float b)

参数：

b：浮点值

另一个提供类似于

新Float(Float.parseFloat(val，10))的函数valueOf(String val ))

语法： public static Float valueOf(String s)

抛出NumberFormatException

参数：

s：一个String对象，被解析为float

抛出：

NumberFormatException：如果字符串不能被分析为浮点值。

parseFloat()：通过解析字符串返回浮点值。与valueOf()不同，因为它返回一个基本的float值，valueOf()返回Float对象。

语法： public static float parseFloat(String val)

抛出NumberFormatException

参数：

val：float的字符串表示形式

抛出：

NumberFormatException：如果字符串不能以给定的基数解析为浮点值。

byteValue()：返回与此浮点对象相对应的字节值。

语法： public byte byteValue()

shortValue()：返回与此浮点对象相对应的短值。

语法： public short shortValue()

intValue()：返回与此浮点对象相对应的int值。

语法： public int intValue()

longValue()：返回与此浮点对象相对应的长整型值。

语法： public long longValue()

doubleValue()：返回与此浮点对象相对应的double值。

语法： public double doubleValue()

floatValue()：返回与此浮点对象相对应的浮点值。

语法： public float floatValue()

hashCode()：返回对应于这个Float对象的哈希码。

语法： public int hashCode()

isNaN()：如果考虑的浮点对象不是数字，则返回true，否则返回false。

语法： public boolean isNaN()

如果我们不需要创建任何浮点对象，则可以使用另一种静态方法是NaN(float val)。它提供了与上述版本类似的功能。

语法： public static boolean isNaN(float val)

参数：

val：浮点值来检查

isInfinite()：如果考虑的浮点对象非常大，则返回true，否则返回false。具体来说，任何正数超过0x7f800000的数字和负数超过0xff800000的数字都是无穷大数值。

语法： public boolean isInfinite()

如果我们不需要创建任何浮点对象，则可以使用另一种静态方法isInfinite(float val)。它提供了与上述版本类似的功能。

语法： public static boolean isInfinte(float val)

参数：

val：浮点值来检查

toHexString()：返回参数float值的十六进制表示形式。

语法： public static String toHexString(float val)

参数：

val：float值，用十六进制字符串表示

floatToIntBits()：返回给定float参数的IEEE 754浮点“单格式”位布局。

语法： public static int floatToIntBits(float val)

参数：

val：要转换的浮点值

floatToRawIntBits()：返回给定float参数的IEEE 754浮点“单一格式”位布局。它不同于以前的方法，因为它保留了Nan值。

语法： public static int floatToRawIntBits(float val)

参数：

val：要转换的浮点值

IntBitsToFloat()：返回与参数的长位模式相对应的浮点值。它确实颠​​倒了前两种方法的工作。

语法： public static float IntBitsToFloat(long b)

参数：

b：长位模式

equals()：用于比较两个Float对象的相等性。如果两个对象都包含相同的浮点值，则此方法返回true。只有在检查平等的情况下才能使用。在其他所有情况下，compareTo方法应该是首选。

语法： public boolean equals(Object obj)

参数：

obj：与之比较的对象

compareTo()：用于比较两个Float对象的数值相等。当比较两个Float值的数值相等时应该使用它，因为它会区分较小值和较大值。返回小于0,0的值，大于0的值小于，等于和大于。

语法： public int compareTo(Float b)

参数：

b：与之比较的浮动对象

compare()：用于比较数值相等的两个基本float值。因为它是一个静态方法，因此可以在不创建任何Float对象的情况下使用它。

语法： public static int compare(float x，float y)

参数：

x：浮点值

y：另一个浮点值

// Java program to illustrate

// various float class methods

// of Java.lang class

public class GfG

{

public static void main(String[] args)

{

float b = 55.05F;

String bb = "45";

// Construct two Float objects

Float x = new Float(b);

Float y = new Float(bb);

// toString()

System.out.println("toString(b) = " + Float.toString(b));

// valueOf()

// return Float object

Float z = Float.valueOf(b);

System.out.println("valueOf(b) = " + z);

z = Float.valueOf(bb);

System.out.println("ValueOf(bb) = " + z);

// parseFloat()

// return primitive float value

float zz = Float.parseFloat(bb);

System.out.println("parseFloat(bb) = " + zz);

System.out.println("bytevalue(x) = " + x.byteValue());

System.out.println("shortvalue(x) = " + x.shortValue());

System.out.println("intvalue(x) = " + x.intValue());

System.out.println("longvalue(x) = " + x.longValue());

System.out.println("doublevalue(x) = " + x.doubleValue());

System.out.println("floatvalue(x) = " + x.floatValue());

int hash = x.hashCode();

System.out.println("hashcode(x) = " + hash);

boolean eq = x.equals(y);

System.out.println("x.equals(y) = " + eq);

int e = Float.compare(x, y);

System.out.println("compare(x,y) = " + e);

int f = x.compareTo(y);

System.out.println("x.compareTo(y) = " + f);

Float d = Float.valueOf("1010.54789654123654");

System.out.println("isNaN(d) = " + d.isNaN());

System.out.println("Float.isNaN(45.12452) = "

+ Float.isNaN(45.12452F));

// Float.POSITIVE_INFINITY stores

// the positive infinite value

d = Float.valueOf(Float.POSITIVE_INFINITY + 1);

System.out.println("Float.isInfinite(d) = "

+ Float.isInfinite(d.floatValue()));

float dd = 10245.21452F;

System.out.println("Float.toString(dd) = "

+ Float.toHexString(dd));

int float_to_int = Float.floatToIntBits(dd);

System.out.println("Float.floatToLongBits(dd) = "

+ float_to_int);

float int_to_float = Float.intBitsToFloat(float_to_int);

System.out.println("Float.intBitsToFloat(float_to_long) = "

+ int_to_float);

}

}

输出：

toString(b) = 55.05

valueOf(b) = 55.05

ValueOf(bb) = 45.0

parseFloat(bb) = 45.0

bytevalue(x) = 55

shortvalue(x) = 55

intvalue(x) = 55

longvalue(x) = 55

doublevalue(x) = 55.04999923706055

floatvalue(x) = 55.05

hashcode(x) = 1113338675

x.equals(y) = false

compare(x,y) = 1

x.compareTo(y) = 1

isNaN(d) = false

Float.isNaN(45.12452) = false

Float.isInfinite(d) = true

Float.toString(dd) = 0x1.4029b8p13

Float.floatToLongBits(dd) = 1176507612

Float.intBitsToFloat(float_to_long) = 10245.215