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

在 Java 中，Byte 類是基本類型 byte 的wrapper class，它包含多種有效處理字節值的方法，例如將其轉換為字符串表示形式，反之亦然。 Byte 類的對象可以保存單個字節值。

Byte 類的構造函數

主要有兩個構造函數來初始化 Byte 對象 -

1. 字節(字節b)

創建一個使用提供的值初始化的 Byte 對象。

Syntax:  
public Byte(byte b)

Parameters :
b : value with which to initialize

2. 字節(字符串)

創建一個 Byte 對象，並使用字符串表示形式提供的字節值進行初始化。默認基數為 10。

Syntax : 
public Byte(String s) throws NumberFormatException

Parameters :
s : string representation of the byte value 

Throws :
NumberFormatException : If the string provided does not represent any byte value.

Java Byte 類中的字段

1. static int BYTES: The number of bytes used to represent a byte value in two’s complement binary form.
2. static byte MAX_VALUE: A constant holding the maximum value a byte can have, 27-1.
3. static byte MIN_VALUE: A constant holding the minimum value a byte can have, -27.
4. static int SIZE: The number of bits used to represent a byte value in two’s complement binary form.
5. static Class<Byte> TYPE: The Class instance representing the primitive type byte.

Java 字節類中的方法

1.toString()

toString()函數返回與字節值對應的字符串。

Syntax : 
public String toString(byte b)

Parameters :
b : byte value for which string representation required.

2.valueOf()：

此函數返回使用提供的值初始化的 Byte 對象。

Syntax : public static Byte valueOf(byte b)

Parameters :
b : a byte value

3. valueOf(字符串 val,int 基數)

另一個重載函數 valueOf(String val,int radix) 提供類似於 new Byte(Byte.parseByte(val,radix)) 的函數

Syntax : 
public static Byte valueOf(String val, int radix)
throws NumberFormatException

Parameters :
val : String to be parsed into byte value
radix : radix to be used while parsing

Throws :
NumberFormatException : if String cannot be parsed to a byte value in given radix.

4. valueOf(字符串值)

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

Syntax : 
 public static Byte valueOf(String s)
 throws NumberFormatException
           
Parameters :
s : a String object to be parsed as byte

Throws :
NumberFormatException : if String cannot be parsed to a byte value in given radix.

5.parseByte()

通過解析提供的基數中的字符串返回字節值。與 valueOf() 不同，它返回原始字節值，而 valueOf() 返回 Byte 對象。

Syntax : 
    public static byte parseByte(String val, int radix)
    throws NumberFormatException

Parameters :
val : String representation of byte 
radix : radix to be used while parsing

Throws :
NumberFormatException : if String cannot be parsed to a byte value in given radix.

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

Syntax : 
 public static byte parseByte(String val)
 throws NumberFormatException

Parameters :
val : String representation of byte 

Throws :
NumberFormatException : if String cannot be parsed to a byte value in given radix.

7.decode()：

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

Syntax : 
 public static Byte decode(String s)
 throws NumberFormatException

Parameters :
s : encoded string to be parsed into byte val

Throws :
NumberFormatException : If the string cannot be decoded into a byte value

8.byteValue()

byteValue() 函數返回與該字節對象對應的字節值。

Syntax : public byte byteValue()

9.shortValue()

返回與此字節對象對應的短值。

Syntax : public short shortValue()

10.intValue()

intValue() 返回與該字節對象對應的int 值。

Syntax : public int intValue()

11.longValue()

longValue() 函數返回與該字節對象對應的長整型值。

Syntax : public long longValue()

12.doubleValue()

返回與此字節對象對應的雙精度值。

Syntax : public double doubleValue()

13.floatValue()

返回與此字節對象對應的浮點值。

Syntax : public float floatValue()

14.hashCode()

hashCode()方法返回與該字節對象對應的哈希碼。

Syntax : public int hashCode()

15.equals()

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

Syntax : 
    public boolean equals(Object obj)

Parameters :
obj : object to compare with

16.compareTo()

compareTo() 用於比較兩個 Byte 對象的數值是否相等。當比較兩個字節值的數值相等時，應該使用它，因為它會區分較小和較大的值。返回小於 0,0 的值，大於 0 的值表示小於、等於和大於。

Syntax : 
 public int compareTo(Byte b)

Parameters :
b : Byte object to compare with

17.compare()

compare() method 比較兩個原始字節值的數值是否相等。由於它是靜態方法，因此可以在不創建任何 Byte 對象的情況下使用它。

Syntax : 
public static int compare(byte x,byte y)

Parameters :
x : byte value
y : another byte value

// Java program to illustrate
// various methods of Byte class
public class Byte_test {
    public static void main(String[] args)
    {
        byte b = 55;
        String bb = "45";
        // Construct two Byte objects
        Byte x = new Byte(b);
        Byte y = new Byte(bb);
        // toString()
        System.out.println("toString(b) = "
                           + Byte.toString(b));
        // valueOf()
        // return Byte object
        Byte z = Byte.valueOf(b);
        System.out.println("valueOf(b) = " + z);
        z = Byte.valueOf(bb);
        System.out.println("ValueOf(bb) = " + z);
        z = Byte.valueOf(bb, 6);
        System.out.println("ValueOf(bb,6) = " + z);
        // parseByte()
        // return primitive byte value
        byte zz = Byte.parseByte(bb);
        System.out.println("parseByte(bb) = " + zz);
        zz = Byte.parseByte(bb, 6);
        System.out.println("parseByte(bb,6) = " + zz);
        // decode()
        String decimal = "45";
        String octal = "005";
        String hex = "0x0f";
        Byte dec = Byte.decode(decimal);
        System.out.println("decode(45) = " + dec);
        dec = Byte.decode(octal);
        System.out.println("decode(005) = " + dec);
        dec = Byte.decode(hex);
        System.out.println("decode(0x0f) = " + dec);
        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 = Byte.compare(x, y);
        System.out.println("compare(x,y) = " + e);
        int f = x.compareTo(y);
        System.out.println("x.compareTo(y) = " + f);
    }
}

toString(b) = 55
valueOf(b) = 55
ValueOf(bb) = 45
ValueOf(bb,6) = 29
parseByte(bb) = 45
parseByte(bb,6) = 29
decode(45) = 45
decode(005) = 5
decode(0x0f) = 15
bytevalue(x) = 55
shortvalue(x) = 55
intvalue(x) = 55
longvalue(x) = 55
doublevalue(x) = 55.0
floatvalue(x) = 55.0
hashcode(x) = 55
x.equals(y) = false
compare(x,y) = 10
x.compareTo(y) = 10

參考文獻：Official Java Documentation