java.lang类_Java中的Java.Lang.Long类 - Break易站

Java 包装类

Java中的Java.Lang.Long类

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

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

语法： public Long(long b)

参数：

b：用于初始化的值

Long(String s)：使用字符串表示形式提供的long值创建一个Long对象。Defalut radix被认为是10。

语法： public Long(String s)

抛出NumberFormatException

参数：

s：long值的字符串表示形式

抛出：

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

方法：

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

语法：public String toString(long b)

参数：

b：需要字符串表示的长整型值。

toHexString()：以十六进制形式返回对应于long值的字符串，即它返回一个字符串，表示十六进制字符中的长整型值 - [0-9] [af]

语法：public String toHexString(long b)

参数：

b：需要十六进制字符串表示的长整型值。

toOctalString()：以八进制形式返回与long值相对应的字符串，即返回一个字符串，表示八进制字符中的长整型值 - [0-7]

语法：public String toOctalString(long b)

参数：

b：需要八进制字符串表示的长整型值。

toBinaryString()：以二进制数字的形式返回对应于long值的字符串，即它返回一个字符串，表示以十六进制字符表示的长整型值 - [0/1]

语法：public String toBinaryString(long b)

参数：

b：需要二进制串表示的long值。

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

语法： public static Long valueOf(long b)

参数：

b：长期价值

另一个提供类似于

新的Long(Long.parseLong(val，radix))函数的重载函数valueOf(String val，long radix))

语法： public static Long valueOf(String val，long radix)

抛出NumberFormatException

参数：

val：要解析为长整型值的字符串

radix：解析时使用的基数

抛出：

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

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

new Long(Long.parseInt(val，10))的函数

语法： public static Long valueOf(String s)

抛出NumberFormatException

参数：

s：要被解析的字符串对象

抛出：

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

parseLong()：通过解析提供的基数字符串来返回long值。与valueOf()不同，因为它返回一个原始的long值，valueOf()返回Long对象。

语法： public static long parseInt(String val，int radix)

抛出NumberFormatException

参数：

val：long的字符串表示

radix：解析时使用的基数

抛出：

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

另一个只包含String作为参数的重载方法，radix被defalut设置为10。

语法： public static long parseLong(String val)

抛出NumberFormatException

参数：

val：long的字符串表示

抛出：

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

getLong()：返回表示与给定系统属性关联的值的Long对象，如果不存在，则返回null。

语法： public static Long getLong(String prop)

参数：

prop：系统属性

另一个重载的方法，如果该属性不存在，则返回第二个参数，即它不会返回null，而是返回用户提供的默认值。

语法： public static Long getLong(String prop，long val)

参数：

prop：系统属性

val：如果属性不存在，则返回值。

另一个重载的方法，根据返回的值解析值，也就是说，如果返回值以“＃”开头，​​而不是解析为十六进制，如果以“0”开头，则解析为八进制，否则为十进制。

语法： public static Long getLong(String prop，Long val)

参数：

prop：系统属性

val：如果属性不存在，则返回值。

decode()：返回一个Long对象，它保存提供的字符串的解码值。提供的字符串必须为以下格式否则会抛出NumberFormatException -

十进制 - (符号)Decimal_Number十六进制

(符号)“0x”十六进制数字十六进制

(符号)“0X”十六

进制数字八进制 - (符号)“0”八进制数字

语法： public static Long decode(String s)

抛出NumberFormatException

参数：

s：编码的字符串被解析为长val

抛出：

NumberFormatException：如果字符串不能解码为一个长整型值

rotateLeft()：通过以给定值的二进制补码形式旋转给定距离左边的位来返回一个基元。当向左旋转时，最重要的位移动到右侧，或者最不重要的位置，即位的循环移动发生。负距离表示正确旋转。

语法： public static long rotateLeft(long val，int dist)

参数：

val：要旋转的长整型值

dist：旋转距离

rotateRight()：通过以给定值的二进制补码形式向右旋转给定距离来返回一个基元。当向右旋转时，最低有效位移动到左侧，或者最重要的位置，即位的循环移动发生。负距离表示左转。

语法： public static long rotateRight(long val，int dist)

参数：

val：要旋转的长整型值

dist：旋转距离

// Java program to illustrate

// various Long class methods

public class Long_test

{

public static void main(String args[])

{

long b = 55;

String bb = "45";

// Construct two Long objects

Long x = new Long(b);

Long y = new Long(bb);

// toString()

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

// toHexString(),toOctalString(),toBinaryString()

// converts into hexadecimal, octal and binary forms.

System.out.println("toHexString(b) =" + Long.toHexString(b));

System.out.println("toOctalString(b) =" + Long.toOctalString(b));

System.out.println("toBinaryString(b) =" + Long.toBinaryString(b));

// valueOf(): return Long object

// an overloaded method takes radix as well.

Long z = Long.valueOf(b);

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

z = Long.valueOf(bb);

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

z = Long.valueOf(bb, 6);

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

// parseLong(): return primitive long value

// an overloaded method takes radix as well

long zz = Long.parseLong(bb);

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

zz = Long.parseLong(bb, 6);

System.out.println("parseLong(bb,6) = " + zz);

// getLong(): can be used to retrieve

// long value of system property

long prop = Long.getLong("sun.arch.data.model");

System.out.println("getLong(sun.arch.data.model) = " + prop);

System.out.println("getLong(abcd) =" + Long.getLong("abcd"));

// an overloaded getLong() method

// which return default value if property not found.

System.out.println("getLong(abcd,10) =" + Long.getLong("abcd", 10));

// decode() : decodes the hex,octal and decimal

// string to corresponding long values.

String decimal = "45";

String octal = "005";

String hex = "0x0f";

Long dec = Long.decode(decimal);

System.out.println("decode(45) = " + dec);

dec = Long.decode(octal);

System.out.println("decode(005) = " + dec);

dec = Long.decode(hex);

System.out.println("decode(0x0f) = " + dec);

// rotateLeft and rotateRight can be used

// to rotate bits by specified distance

long valrot = 2;

System.out.println("rotateLeft(0000 0000 0000 0010 , 2) =" +

Long.rotateLeft(valrot, 2));

System.out.println("rotateRight(0000 0000 0000 0010,3) =" +

Long.rotateRight(valrot, 3));

}

}

输出：

toString(b) = 55

toHexString(b) =37

toOctalString(b) =67

toBinaryString(b) =110111

valueOf(b) = 55

ValueOf(bb) = 45

ValueOf(bb,6) = 29

parseInt(bb) = 45

parseInt(bb,6) = 29

getLong(sun.arch.data.model) = 64

getLong(abcd) =null

getLong(abcd,10) =10

decode(45) = 45

decode(005) = 5

decode(0x0f) = 15

rotateLeft(0000 0000 0000 0010 , 2) =8

rotateRight(0000 0000 0000 0010,3) =1073741824

更多的Long类方法是 -

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

语法： public int hashCode()

bitcount()：返回给定位数的二进制补码。

语法： public static int bitCount(long i)

参数：

我：长数值的设置位数

numberOfLeadingZeroes()：返回数值的二进制补码形式的最高1位之前的0位数，即如果二进制补码形式的数字为0000 1010 0000 0000，则此函数返回4。

语法： public static int numberofLeadingZeroes(long i)

参数：

我：长的价值，其前导零计数二进制补码形式

numberOfTrailingZeroes()：返回数值的二进制补码形式的最后1位之后的0位数，即如果二进制补码形式的数字为0000 1010 0000 0000，则此函数返回9。

语法： public static int numberofTrailingZeroes(long i)

参数：

i：长尾的零值以二进制补码形式计数

highestOneBit()：在给定值中最高一位的位置返回最多只有一位的值。如果给定值为0，则返回0，即如果该数字为0000 0000 0000 1111，则该函数返回0000 0000 0000 1000(给定数字中的最高一位)

语法： public static long highestOneBit(long i)

参数：

我：长期价值

LowestOneBit()：返回给定值中最低一位的位置，最多只有一位。如果给定值为0，则返回0，即如果该数字为0000 0000 0000 1111，则该函数返回0000 0000 0000 0001(在给定数字中最高一位)

语法： public static long LowestOneBit(long i)

参数：

我：长期价值

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

语法： public boolean equals(Object obj)

参数：

obj：与之比较的对象

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

语法： public int compareTo(Long b)

参数：

b：比较长的对象

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

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

参数：

x：长期价值

y：另一个长期价值

signum()：对于负值返回-1，对于0而言返回0，对于大于0的值则返回+1。

语法： public static int signum(long val)

参数：

val：需要签名的长整型值。

reverse()：返回一个原始的long值，它反转给定long值的二进制补码格式中的位的顺序。

语法： public static long reverseBytes(long val)

参数：

val：长整型值，其位顺序颠倒。

reverseBytes()：返回一个原始长整型值，它反转给定long值的二进制补码形式的字节顺序。

语法： public static long reverseBytes(long val)

参数：

val：长整型值，其位顺序颠倒。

// Java program to illustrate

// various Long methods

public class Long_test

{

public static void main(String args[])

{

long b = 55;

String bb = "45";

// Construct two Long objects

Long x = new Long(b);

Long y = new Long(bb);

// xxxValue can be used to retrieve

// xxx type value from long value.

// xxx can be int,byte,short,long,double,float

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());

long value = 45;

// bitcount() : can be used to count set bits

// in twos complement form of the number

System.out.println("Long.bitcount(value)=" + Long.bitCount(value));

// numberOfTrailingZeroes and numberOfLeaadingZeroes

// can be used to count prefix and postfix sequence of 0

System.out.println("Long.numberOfTrailingZeros(value)=" +

Long.numberOfTrailingZeros(value));

System.out.println("Long.numberOfLeadingZeros(value)=" +

Long.numberOfLeadingZeros(value));

// highestOneBit returns a value with one on highest

// set bit position

System.out.println("Long.highestOneBit(value)=" +

Long.highestOneBit(value));

// highestOneBit returns a value with one on lowest

// set bit position

System.out.println("Long.lowestOneBit(value)=" +

Long.lowestOneBit(value));

// reverse() can be used to reverse order of bits

// reverseytes() can be used to reverse order of bytes

System.out.println("Long.reverse(value)=" + Long.reverse(value));

System.out.println("Long.reverseBytes(value)=" +

Long.reverseBytes(value));

// signum() returns -1,0,1 for negative,0 and positive

// values

System.out.println("Long.signum(value)=" + Long.signum(value));

// hashcode() returns hashcode of the object

int hash = x.hashCode();

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

// equals returns boolean value representing equality

boolean eq = x.equals(y);

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

// compare() used for comparing two int values

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

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

// compareTo() used for comparing this value with some

// other value

int f = x.compareTo(y);

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

}

}

输出：

bytevalue(x) = 55

shortvalue(x) = 55

intvalue(x) = 55

longvalue(x) = 55

doublevalue(x) = 55.0

floatvalue(x) = 55.0

Long.bitcount(value)=4

Long.numberOfTrailingZeros(value)=0

Long.numberOfLeadingZeros(value)=58

Long.highestOneBit(value)=32

Long.lowestOneBit(value)=1

Long.reverse(value)=-5476377146882523136

Long.reverseBytes(value)=3242591731706757120

Long.signum(value)=1

hashcode(x) = 55

x.equals(y) = false

compare(x,y) = 1

x.compareTo(y) = 1