d java.lang.double_Java中的Java.Lang.Double类 - Break易站

Java 包装类

Java中的Java.Lang.Double类

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

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

语法： public Double(Double d)

参数：

d：用于初始化的值

Double(String s)：创建一个使用字符串表示形式提供的解析的double值初始化的Double对象。Defalut radix被认为是10。

语法： public Double(String s)

抛出NumberFormatException

参数：

s：字节值的字符串表示

抛出：

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

方法：

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

语法：public String toString(double b)

参数：

b：需要字符串表示的双精度值。

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

语法： public static Double valueOf(double b)

参数：

b：双重值

另一个重载函数valueOf(String val)提供了类似于

新的Double(Double.parseDouble(val，10))的函数

语法： public static Double valueOf(String s)

抛出NumberFormatException

参数：

s：要被解析为double的String对象

抛出：

NumberFormatException：如果字符串无法在给定基数中解析为double值。

parseDouble()：通过解析字符串返回double值。与valueOf()不同，因为它返回一个原始double值，valueOf()返回Double对象。

语法： public static double parseDouble(String val)

throws NumberFormatException

参数：

val：double的字符串表示形式

抛出：

NumberFormatException：如果字符串无法在给定基数中解析为double值。

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()：返回对应于这个Double对象的哈希码。

语法： public int hashCode()

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

语法： public boolean isNaN()

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

语法： public static boolean isNaN(double val)

参数：

val：双重值检查

isInfinite()：如果考虑的双重对象非常大，则返回true，否则返回false。具体来说，在正方向上超出0x7ff0000000000000L且在负方向上超出0xfff0000000000000L的任何数字都是无穷大值。

语法： public boolean isInfinite()

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

语法： public static boolean isInfinte(double val)

参数：

val：双重值检查

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

语法： public static String toHexString(double val)

参数：

val：用十六进制字符串表示的double值

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

语法： public static long doubleToLongBits(double val)

参数：

val：双值转换

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

语法： public static long doubleToRawLongBits(double val)

参数：

val：双值转换

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

语法： public static double LongBitsToDouble(long b)

参数：

b：长位模式

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

语法： public boolean equals(Object obj)

参数：

obj：与之比较的对象

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

语法： public int compareTo(Double b)

参数：

b：与双重对象进行比较

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

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

参数：

x：双倍值

Y：另一个双重价值

// Java program to illustrate

// various Double class methods

// of java.lang class

public class Double_test

{

public static void main(String[] args)

{

double b = 55.05;

String bb = "45";

// Construct two Double objects

Double x = new Double(b);

Double y = new Double(bb);

// toString()

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

// valueOf()

// return Double object

Double z = Double.valueOf(b);

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

z = Double.valueOf(bb);

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

// parseDouble()

// return primitive double value

double zz = Double.parseDouble(bb);

System.out.println("parseDouble(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 = Double.compare(x, y);

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

int f = x.compareTo(y);

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

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

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

System.out.println("Double.isNaN(45.12452) = " + Double.isNaN(45.12452));

// Double.POSITIVE_INFINITY stores

// the positive infinite value

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

System.out.println("Double.isInfinite(d) = " +

Double.isInfinite(d.doubleValue()));

double dd = 10245.21452;

System.out.println("Double.toString(dd) = " + Double.toHexString(dd));

long double_to_long = Double.doubleToLongBits(dd);

System.out.println("Double.doubleToLongBits(dd) = " + double_to_long);

double long_to_double = Double.longBitsToDouble(double_to_long);

System.out.println("Double.LongBitsToDouble(double_to_long) = " +

long_to_double);

}

}

输出：

toString(b) = 55.05

valueOf(b) = 55.05

ValueOf(bb) = 45.0

parseDouble(bb) = 45.0

bytevalue(x) = 55

shortvalue(x) = 55

intvalue(x) = 55

longvalue(x) = 55

doublevalue(x) = 55.05

floatvalue(x) = 55.05

hashcode(x) = 640540672

x.equals(y) = false

compare(x,y) = 1

x.compareTo(y) = 1

isNaN(d) = false

Double.isNaN(45.12452) = false

Double.isInfinite(d) = true

Double.toString(dd) = 0x1.4029b7564302bp13

Double.doubleToLongBits(dd) = 4666857980575363115

Double.LongBitsToDouble(double_to_long) = 10245.21452