带你详细了解OpenJDK 11 Byte类

【读码JDK】-java.lang.Byte类Api介绍及测试

toString

返回表示指定byte的新String对象，转换为10进制

byte b = 0x6E;
System.out.println(Byte.toString(b));
	
/**
 * 输出：
 * 110
 */

valueOf

返回表示指定的byte值的Byte实例。
如果不需要新的Byte实例，优先使用此方法，而不是构造函数Byte(byte) ， 此方法有更好的空间和时间性能，因为所有字节值都被缓存。

byte b = 1;
Byte B = Byte.valueOf(b);
Byte C = Byte.valueOf(b);
System.out.println("B==C:" + (B == C));
/**
 * 输出
 * B==C:true
 */

第二个参数表示第一个参数所表示的进制
就像该参数被赋予parseByte(java.lang.String, int)方法一样。
结果是Byte对象，表示字符串指定的byte值，该值从缓存中读取，输出10进制。

String s1 = "123";
Byte B1 = Byte.valueOf(s1, 10);
Byte B2 = Byte.valueOf(s1, 8);
assert B1 == 123; //true
assert B2 == 83; //true

parseByte

将字符串参数解析为第二个参数指定基数的带符号byte 。

字符串中的字符必须是数字指定基数的，（如通过确定是否Character.digit(char, int) 返回一个非负的值）不同之处在于第一个字符可以是ASCII减号’-’ （ ‘-’ ），以指示一个负值或ASCII加号’+’ （ ‘+’ ）表示正值。 返回结果byte值。

如果发生以下任何一种情况，则抛出类型NumberFormatException的异常：

1、第一个参数是null或者是长度为零的字符串。
2、基数小于Character.MIN_RADIX或大于Character.MAX_RADIX 。
3、字符串的任何字符不是指定基数的数字，所不同的是第一个字符可以是负号’-’ （ ‘-’ ）或加号’+’ （ ‘+’ ），前提是所述字符串比长度1更长。
4、字符串表示的值不是byte类型的值。

参数
s -所述 String含有 byte表示被解析
radix - 解析 s使用的基数 结果 byte由指定基数中的字符串参数表示的值

异常
NumberFormatException - 如果字符串不包含可解析的 byte 。

String s1 = "123";
System.out.println(Byte.parseByte(s1, 10));
 //代表s1 为8进制，输出10进制
 System.out.println(Byte.parseByte(s1, 8));

 String s2 = "-1a";
 System.out.println(Byte.parseByte(s2, 16));

 //将字符串参数解析为带符号的十进制byte
 System.out.println(Byte.parseByte(s1));

 /**
  * 输出：
  * 123
  * 83
  * -26
  * 123
  */

decode

将String解码为Byte

//10进制
Byte code = Byte.decode("10");
assert code == 10; //true
//16进制
Byte code1 = Byte.decode("0x10");
assert code1 == 16;//true
//16进制
Byte code2 = Byte.decode("#10");
assert code2 == 16;//true
//8进制
Byte code3 = Byte.decode("010");
assert code3 == 8;//true

Byte code4 = Byte.decode("-0x10");
assert code4 == -16;//true

//抛出异常,java.lang.NumberFormatException: Sign character in wrong position
//Byte code5 = Byte.decode("0x-10");

byteValue

返回Byte的基本类型值

Byte B = Byte.valueOf("123");
byte b = B.byteValue();

shortValue

转换为类型 short后此对象表示的数值

        Byte B = Byte.valueOf("123");
        short st = B.shortValue();

intValue

转换为类型 int后此对象表示的数值

        Byte B = Byte.valueOf("123");
        int st = B.intValue();

longValue

转换为类型 long后此对象表示的数值

        Byte B = Byte.valueOf("123");
        long lg = B.longValue();

floatValue

转换为类型 float后此对象表示的数值

		Byte B = Byte.valueOf("123");
        float ft = B.floatValue();
        System.out.println(ft); //123.0

doubuleValue

转换为类型 double后此对象表示的数值

        Byte B = Byte.valueOf("123");
        double db = B.doubleValue();

hashCode

        Byte B = Byte.valueOf("123");
        /*
        返回此Byte的哈希码; 等于调用intValue()的结果
         */
        System.out.println(B.hashCode());

        /*
        返回byte值的哈希码; 与Byte.hashCode()兼容
         */
        byte b = 123;
        System.out.println(Byte.hashCode(b));
        
        /**
         * 输出：
         * 123
         * 123
         */

equals

将此对象与指定的对象进行比较。
当且仅当参数不是null并且是包含与此对象相同的byte值的Byte对象时，结果为true

        Byte B1 = Byte.valueOf("123");
        Byte B2 = Byte.valueOf("123");
        Byte B3 = new Byte("123");

        System.out.println(B1.equals(B2));
        System.out.println(B1.equals(B3));
        System.out.println(B1 == B2);
        System.out.println(B1 == B3);
         /**
         * 输出：
         * true
         * true
         * true
         * false
         */

compareTo

以数字方式比较两个 Byte对象
值0，两个参数相等 ;
值小于0 ，此参数小于第二个参数;
值大于0，此参数大于第二个参数

        Byte B1 = Byte.valueOf("123");
        Byte B2 = Byte.valueOf("12");
        assert B1.compareTo(B2) > 0; //true
        assert B2.compareTo(B1) <0; //true

compare

以数字方式比较两个 Byte对象
compareTo实际调用该静态方法

        Byte B1 = Byte.valueOf("123");
        Byte B2 = Byte.valueOf("12");
        assert Byte.compare(B1, B2) > 0;

compareUnsigned

忽略符号进行比较

        Byte B1 = Byte.valueOf("-123");
        Byte B2 = Byte.valueOf("12");
        assert Byte.compareUnsigned(B1, B2) > 0; //true

toUnsignedInt

通过无符号转换将参数转换为int

        Byte B1 = Byte.valueOf("-123");
        System.out.println(Byte.toUnsignedInt(B1));
        Byte B2 = Byte.valueOf("123");
        System.out.println(Byte.toUnsignedInt(B2));

        /**
         * 输出：
         * 133
         * 123
         */

toUnsignedLong

通过无符号转换将参数转换为long

        Byte B1 = Byte.valueOf("-123");
        long b1 = Byte.toUnsignedLong(B1);
        System.out.println(b1); //123