7 java.lang.Byte

1️⃣类定义

public final class Byte extends Number implements Comparable<Byte>

1. 类被声明为final的,表示不能被继承;
2. 继承了Number抽象类,可以用于数字类型的一系列转换;
3. 实现了Comparable接口,可以用于比较

---

2️⃣属性

    /**
     * byte的最小值，也就是-2的7次方
     */
    public static final byte   MIN_VALUE = -128;

    /**
     * byte的最大值，也即2的7次方减1
     */
    public static final byte   MAX_VALUE = 127;
    
    /**
     * @SuppressWarnings("unchecked")表示对警告保持静默 
     * 获取Byte的原始class对象
     */
    @SuppressWarnings("unchecked")
    public static final Class<Byte> TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");

    /**
     * Byte对象中具体的byte值，定义为final
     */
    private final byte value;
    
    /**
     * 用于表示二进制补码二进制形式的字节值的位数(定义了Byte的大小，为8个位，即一个字节)
     */
    public static final int SIZE = 8;

    /**
     * 用于表示二进制补码二进制形式的字节值的字节数(给出了字节，即SIZE/Byte.SIZE = 1;占一个字节)
     */
    public static final int BYTES = SIZE / Byte.SIZE;

    /**  
     * 序列化
     */
    private static final long serialVersionUID = -7183698231559129828L;

---

3️⃣构造器

    public Byte(byte value) {
        this.value = value;
    }

    /**
     * 参数为字符串形式传入的value必须是byte类型的值，字符串s必须是可以转换为数字的字符串，不然会报错
     */
    public Byte(String s) throws NumberFormatException {
        this.value = parseByte(s, 10);
    }

---

4️⃣内部类

    /**
     * Byte对象的缓存类
     */
    private static class ByteCache {
        private ByteCache(){}
        /**
         * 缓存数组
         */
        static final Byte cache[] = new Byte[-(-128) + 127 + 1];
        // 缓存初始化，范围是-128到127
        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Byte((byte)(i - 128));
        }
    }

定义了一个Byte的缓存值，将-128~127写入到一个cache数组，当在这个区间的时候，JVM会直接使用缓存值，但是当超过这个区间的话，会发生溢出的现象，128会变为-128，会从最小值继续循环计算

---

5️⃣方法

① toString : 注意两次toString调用的Integer.toString()方法不是一个toString();

    /**
     * 静态toString,底层调用Integer.toString(也是一个静态方法)
     * 将byte强转为int值在传入一个默认的基数10()
     */
    public static String toString(byte b) {
        return Integer.toString((int)b, 10);
    }

    /**
     * 这里是先把byte升级为int，然后用Integer的toString静态方法
     */
    public String toString() {
        return Integer.toString((int)value);
    }

② valueOf

    /**
     * 封装基础byte到Byte对象，其实就是从缓存数组中取出对应的值
     * 在这里使用到了上边定义的内部类
     */
    public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }
    
    /**
     * 重载方法 : 将字符串根据指定的基数包装成Byte对象
     */
    public static Byte valueOf(String s, int radix)
        throws NumberFormatException {
        return valueOf(parseByte(s, radix));
    }
    
    /**
     * 重载方法 : 将字符串根据十进制包装成Byte对象实际调用的是valueOf(String s, int radix)
     * 这个重载方法,默认的基数为10
     */
    public static Byte valueOf(String s) throws NumberFormatException {
        return valueOf(s, 10);
    }

③ parseByte

    /**
     * 将字符串根据指定的基数格式化成基础byte,字符串可以包含数组和字母基数最大为36;
     * 另外需要注意的是这个方法将在源码中被多次调用
     */
    public static byte parseByte(String s, int radix)
        throws NumberFormatException {
        // 调用了Integer的格式化方法
        int i = Integer.parseInt(s, radix);
        if (i < MIN_VALUE || i > MAX_VALUE)
            throw new NumberFormatException(
                "Value out of range. Value:\"" + s + "\" Radix:" + radix);
        return (byte)i;
    }
    
    /**
     * 重载的方法实际调用的是parseByte(String s, int radix),传入的基数默认为10
     */
    public static byte parseByte(String s) throws NumberFormatException {
        return parseByte(s, 10);
    }

④ decode

    /**
     * 将2进制或者是8进制或者是16进制的字符串转成封装成Byte对象
     */
    public static Byte decode(String nm) throws NumberFormatException {
        // 调用Integer.decode()进行处理
        int i = Integer.decode(nm);
        if (i < MIN_VALUE || i > MAX_VALUE)
            throw new NumberFormatException(
                    "Value " + i + " out of range from input " + nm);
        // 将处理结果的值进行强转调用valueOf(byte b);
        return valueOf((byte)i);
    }

⑤ 来自于继承类的方法

    /**
     * 获取Byte对象的byte值，继承自Number方法
     */
    public byte byteValue() {
        return value;
    }

    /**
     * 将当前对象强转成short，继承自Number方法
     */
    public short shortValue() {
        return (short) value;
    }

    /**
     * 将当前对象强转成int，继承自Number方法
     */
    public int intValue() {
        return (int) value;
    }

    /**
     * 将当前对象强转成long，继承自Number方法
     */
    public long longValue() {
        return (long) value;
    }

    /**
     * 将当前对象强转成float，继承自Number方法
     */
    public float floatValue() {
        return (float) value;
    }

    /**
     * 将当前对象强转成double，继承自Number方法
     */
    public double doubleValue() {
        return (double) value;
    }

⑥ hashCode

    /**
     * 重写Object中的hashCode,实际调用的是hashCode(byte value)
     */
    @Override
    public int hashCode() {
        return Byte.hashCode(value);
    }

    /**
     * hashCode，静态，byte的hashCode就是它的值
     */
    public static int hashCode(byte value) {
        return (int)value;
    }

⑦ equals : 这个方法就不进行过多的介绍了,实际就行进行类型以及值的判断

    public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }

⑧ compareTo与compare

    /**
     * 比较当前对象与指定Byte,实际调用的是compare(byte x, byte y) 
     */
    public int compareTo(Byte anotherByte) {
        return compare(this.value, anotherByte.value);
    }

    /**
     * 比较两个byte
     */
    public static int compare(byte x, byte y) {
        return x - y;
    }

⑨ 转换方法

    /**
     * 将指定byte转换为无符号int
     */
    public static int toUnsignedInt(byte x) {
        return ((int) x) & 0xff;
    }

    /**
     * 将指定byte专为无符号long
     */
    public static long toUnsignedLong(byte x) {
        return ((long) x) & 0xffL;
    }

---

6️⃣总结

1. 声明了一个ByteCache内部类用来作为Byte的缓存值
2. parseByte(String s, int radix)方法的两个参数,radix参数代表基数radix传入的是几，s就是几进制数，解析完结果是十进制数
3. 定义了SIZE和BYTES两个常量来value的字节数和位数;