Java Java类

Byte 类是原始类型 byte 的包装类，它包含几种有效处理字节值的方法，例如将其转换为字符串表示形式，反之亦然。 Byte 类的对象可以保存单个字节值。初始化一个 Byte 对象主要有两个构造函数——

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

Syntax:  public Byte(byte b)
Parameters :
b : value with which to initialize

Byte(String s)：创建一个用字符串表示提供的字节值初始化的 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.

Byte 类中的字段：

static int BYTES ：用于表示二进制补码形式的字节值的字节数。
static byte MAX_VALUE ：一个常量，保存一个字节可以具有的最大值，27-1。
static byte MIN_VALUE ：一个常量，保存一个字节可以具有的最小值，-27。
static int SIZE ：用于以二进制补码形式表示字节值的位数。
static Class TYPE ：表示原始类型字节的 Class 实例。

方法：

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

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

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

Syntax : public static Byte valueOf(byte b)
Parameters :
b : a byte value

另一个重载函数valueOf(String val,int 函数 ) 提供类似于
新字节(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.

另一个重载函数valueOf(String 函数 ) 提供类似于
新字节(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.

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.

另一个仅包含 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.

decode() ：返回一个 Byte 对象，其中包含提供的字符串的解码值。提供的字符串必须采用以下形式，否则将抛出 NumberFormatException -
Decimal-（符号）Decimal_Number
Hex-（符号）”0x”Hex_Digits
Hex-（符号）“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

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

Syntax : public byte byteValue()

shortValue() ：返回与此字节对象对应的短值。

Syntax : public short shortValue()

intValue() ：返回与此字节对象对应的 int 值。

Syntax : public int intValue()

longValue() ：返回与此字节对象对应的长值。

Syntax : public long longValue()

doubleValue() ：返回与此字节对象对应的双精度值。

Syntax : public double doubleValue()

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

Syntax : public float floatValue()

hashCode() ：返回此字节对象对应的哈希码。

Syntax : public int hashCode()

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

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

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

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

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

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

Java

// 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