Java Java.Lang.Long用法及代碼示例

Long 類是基本類型 long 的wrapper class，它包含多種有效處理 long 值的方法，例如將其轉換為字符串表示形式，反之亦然。 Long 類的對象可以保存單個 long 值。主要有兩個構造函數來初始化 Long 對象 -

• 長(長b)：創建一個使用提供的值初始化的 Long 對象。

Syntax : public Long(long b)
Parameters :
b : value with which to initialize

• 長(字符串)：創建一個 Long 對象，並使用字符串表示形式提供的 long 值進行初始化。默認基數為 10。

Syntax : public Long(String s) 
                    throws NumberFormatException
Parameters :
s : string representation of the long value 
Throws :
NumberFormatException : If the string provided does not represent any long value.

方法：

1.toString()：返回long值對應的字符串。

Syntax : public String toString(long b)
Parameters :
b : long value for which string representation required.

2. Long.toHexString()):以十六進製形式返回long值對應的字符串，即返回以十六進製字符表示long值的字符串-[0-9][a-f]

Syntax : public String toHexString(long b)
Parameters :
b : long value for which hex string representation required.

3. toOctalString()：返回八進製形式的long值對應的字符串，即返回八進製字符表示long值的字符串-[0-7]

Syntax : public String toOctalString(long b)
Parameters :
b : long value for which octal string representation required.

4. toBinaryString()：返回long值對應的二進製數字的字符串，即返回代表long值的十六進製字符的字符串-[0/1]

Syntax : public String toBinaryString(long b)
Parameters :
b : long value for which binary string representation required.

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

Syntax : public static Long valueOf(long b)
Parameters :
b : a long value

另一個重載函數 valueOf(String val,long radix) 提供類似於
new Long(Long.parseLong(val,基數))

Syntax : public static Long valueOf(String val, long radix)
            throws NumberFormatException
Parameters :
val : String to be parsed into long value
radix : radix to be used while parsing
Throws :
NumberFormatException : if String cannot be parsed to a long value in given radix.

另一個重載函數 valueOf(String val) 提供類似於
new Long(Long.parseInt(val,10))

Syntax : public static Long valueOf(String s)
           throws NumberFormatException
Parameters :
s : a String object to be parsed as long
Throws :
NumberFormatException : if String cannot be parsed to a long value in given radix.

6. parseLong()：通過解析提供的基數中的字符串返回long值。與 valueOf() 不同，它返回原始 long 值，而 valueOf() 返回 Long 對象。

Syntax : public static long parseInt(String val, int radix)
             throws NumberFormatException
Parameters :
val : String representation of long 
radix : radix to be used while parsing
Throws :
NumberFormatException : if String cannot be parsed to a long value in given radix.

另一個僅包含 String 作為參數的重載方法，基數默認設置為 10。

Syntax : public static long parseLong(String val)
             throws NumberFormatException
Parameters :
val : String representation of long 
Throws :
NumberFormatException : if String cannot be parsed to a long value in given radix.

7. getLong()：返回表示與給定係統屬性關聯的值的 Long 對象，如果不存在則返回 null。

Syntax : public static Long getLong(String prop)
Parameters :
prop : System property

另一個重載方法，如果屬性不存在，則返回第二個參數，即它不返回 null，而是返回用戶提供的默認值。

Syntax : public static Long getLong(String prop, long val)
Parameters :
prop : System property
val : value to return if property does not exist.

另一種重載方法，根據返回值解析值，即如果返回值以“#”開頭，則解析為十六進製，如果以“0”開頭，則解析為八進製，否則解析為十進製。

Syntax : public static Long getLong(String prop, Long val)
Parameters :
prop : System property
val : value to return if property does not exist.

8. Long decode()：返回一個 Long 對象，其中保存所提供字符串的解碼值。提供的字符串必須采用以下形式，否則將拋出NumberFormatException -
十進製-(符號)Decimal_Number
十六進製-(符號)”0x”Hex_Digits
十六進製-(符號)”0X”Hex_Digits
八進製-(符號)”0″Octal_Digits

Syntax : public static Long decode(String s)
             throws NumberFormatException
Parameters :
s : encoded string to be parsed into long val
Throws :
NumberFormatException : If the string cannot be decoded into a long value

9. rotateLeft()：通過以給定值的二進製補碼形式將位向左旋轉給定距離，返回原始 long。當向左旋轉時，最高有效位移動到右側，或最低有效位置，即發生位的循環移動。負距離表示右旋轉。

Syntax : public static long rotateLeft(long val, int dist)
Parameters :
val : long value to be rotated
dist : distance to rotate

10. rotateRight()：通過以給定值的二進製補碼形式將位向右旋轉給定距離，返回原始 long。當向右旋轉時，最低有效位移動到左側，或者最高有效位置，即發生位的循環移動。負距離表示左旋轉。

Syntax : public static long rotateRight(long val, int dist)
Parameters :
val : long value to be rotated
dist : distance to rotate

// 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
parseLong(bb) = 45
parseLong(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) =4611686018427387904

更多的 Long 類方法是 -

11. Java lang.Long.byteValue()):返回與此長對象對應的字節值。

Syntax : public byte byteValue()

12.shortValue()：返回與該Long Object對應的short值。

Syntax : public short shortValue()

13. intValue()：返回該Long Object對應的int值。

Syntax : public int intValue()

14. Long longValue()：返回與此長對象對應的long值。

Syntax : public long longValue()

15. doubleValue()：返回與該Long Object對應的double值。

Syntax : public double doubleValue()

16.floatValue()：返回與該Long Object對應的浮點值。

Syntax : public float floatValue()

17.hashCode()：返回該Long Object對應的hashcode。

Syntax : public int hashCode()

18. bitcount()：返回長給定的二進製補碼中設置的位數。

Syntax : public static int bitCount(long i)
Parameters :
i : long value whose set bits to count

19. Java lang.Long.numberOfLeadingZeros()：以二進製補碼形式返回值的最高 1 位之前的 0 位的數量，即，如果二進製補碼形式的數字為 0000 1010 0000 0000，則此函數將返回 4。

Syntax : public static int numberofLeadingZeroes(long i)
Parameters :
i : long value whose leading zeroes to count in twos complement form

20. Java lang.Long.numberOfTrailingZeros()：以二進製補碼形式返回值的最後 1 位之後的 0 位的數量，即，如果二進製補碼形式的數字為 0000 1010 0000 0000，則此函數將返回 9。

Syntax : public static int numberofTrailingZeroes(long i)
Parameters :
i : long value whose trailing zeroes to count in twos complement form

21. Java lang.Long.highestOneBit()：返回一個至多隻有一位的值，位於給定值中最高一位的位置。如果給定值為 0，即返回 0，即如果數字為 0000 0000 0000 1111，則此函數返回 0000 0000 0000 1000(給定數字中的最高一位)

Syntax : public static long highestOneBit(long i)
Parameters :
i : long value 

22. Java lang.Long.lowestOneBit()：返回一個最多包含一位的值，位於給定值中最低一位的位置。如果給定的值為 0，即如果數字為 0000 0000 0000 1111，則返回 0，則此函數返回 0000 0000 0000 0001(給定數字中的最高一位)

Syntax : public static long LowestOneBit(long i)
Parameters :
i : long value 

23. Long equals()：用於比較兩個 Long 對象的相等性。如果兩個對象包含相同的 long 值，則此方法返回 true。僅應在檢查相等性時使用。在所有其他情況下，compareTo 方法應該是首選。

Syntax : public boolean equals(Object obj)
Parameters :
obj : object to compare with

24. long compareTo()：用於比較兩個 Long 對象的數值是否相等。在比較兩個 Long 值的數值相等時應使用此選項，因為它會區分較小值和較大值。返回小於 0,0 的值，大於 0 的值表示小於、等於和大於。

Syntax : public int compareTo(Long b)
Parameters :
b : Long object to compare with

25. compare()：用於比較兩個原始長整型值的數值是否相等。由於它是靜態方法，因此可以在不創建任何 Long 對象的情況下使用它。

Syntax : public static int compare(long x,long y)
Parameters :
x : long value
y : another long value

26. Long signum()：對於負值返回 -1，對於 0 返回 0，對於大於 0 的值返回 +1。

Syntax : public static int signum(long val)
Parameters :
val : long value for which signum is required.

27. Java lang.Long.reverse()：返回一個原始的 long 值，反轉給定 long 值的二進製補碼形式的位順序。

Syntax : public static long reverseBytes(long val)
Parameters :
val : long value whose bits to reverse in order.

28. reverseBytes()：返回一個原始 long 值，以給定 long 值的二進製補碼形式反轉字節順序。

Syntax : public static long reverseBytes(long val)
Parameters :
val : long value whose bits to reverse in order.

// 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
        // reverseBytes() 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