JDK源码之Byte类分析

一 简介

byte，即字节，由8位的二进制组成。在Java中，byte类型的数据是8位带符号的二进制数,以二进制补码表示的整数
取值范围：默认值为0，最小值为-128（-2^{7）;最大值是127（2}7-1）
Byte类是byte的包装类,被final修饰，不能被继承，继承了Number类，可以用于数字类型的一系列转换,还实现了Comparable接口，可以用于比较

二 Number抽象类

Java 语言为每一个内置数据类型提供了对应的包装类。
Number类是java.lang包下的一个抽象类，提供了将包装类型拆箱成基本类型的方法，所有基本类型的数据包装类型都继承了该抽象类(除了Character、Boolean)，并且是final声明不可继承改变
一般情况下我们会使用数据的基本数据类型：byte、int、short、long、double、float；
对应的包装类型：Byte、Integer、Short、Long、Double、Float; 每个包装类型都实现了所有类型转换的方法
该抽象类中定义方法都由子类去具体实现:

    public abstract class Number implements java.io.Serializable {

        public abstract int intValue();

        public abstract long longValue();

        public abstract float floatValue();

        public abstract double doubleValue();

        public byte byteValue() {
            return (byte)intValue();
        }

        public short shortValue() {
            return (short)intValue();
        }

        private static final long serialVersionUID = -8742448824652078965L;
    }

三 源码分析

    /**
     * byte 最小值的常量 -2 ^ 7.
     * Java 中用补码表示二进制数, 补码最高位表示符号位，0 表示正数，1 表示负数.
     * 正数补码为其本身; 负数补码为其各位取反加1
     */
    public static final byte   MIN_VALUE = -128;

    //  byte 最大值为 2 ^ 7 -1
    public static final byte   MAX_VALUE = 127;

    // Byte类型class实例
    @SuppressWarnings("unchecked")
    public static final Class<Byte>     TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");

    public static String toString(byte b) {
        return Integer.toString((int)b, 10);//按十进制数处理
    }

    //静态内部类,缓存使用
    private static class ByteCache {
        private ByteCache(){}
        //缓存数组,长度为 128(负数) + 127(正数) + 1(0)
        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对象,从缓存中获取初始化好的Byte实例
    @HotSpotIntrinsicCandidate
    public static Byte valueOf(byte b) {
        final int offset = 128;
        return Byte.ByteCache.cache[(int)b + offset];
    }

    //解析字符串返回Byte包装类实例
    public static Byte valueOf(String s) throws NumberFormatException {
        return valueOf(s, 10);// 调用下面方法
    }

    //指定字符串进制数进行解析,返回包装类
    public static Byte valueOf(String s, int radix)
            throws NumberFormatException {
        return valueOf(parseByte(s, radix));//调用下面方法
    }

    //解析String为byte基本类型,默认是十进制数
    public static byte parseByte(String s) throws NumberFormatException {
        return parseByte(s, 10);//调用下面方法
    }

    //将字符串解析为byte类型,radix是基数，radix是几，s就是几进制数，解析完结果是十进制数
    public static byte parseByte(String s, int radix)
            throws NumberFormatException {
        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;
    }
    //可解析以0x，＃或0前缀的十六进制八进制等等的数值,valueOf只支持十进制,基数默认写死10了
    public static Byte decode(String nm) throws NumberFormatException {
        int i = Integer.decode(nm);
        if (i < MIN_VALUE || i > MAX_VALUE)
            throw new NumberFormatException(
                    "Value " + i + " out of range from input " + nm);
        return valueOf((byte)i);
    }

    // Byte类型的基本数值
    private final byte value;

    //构造器: jdk9后已废弃(每次都会创建新的),推荐使用valueOf方法,(使用缓存,以节省性能)
    @Deprecated(since="9")
    public Byte(byte value) {
        this.value = value;
    }
    @Deprecated(since="9")
    public Byte(String s) throws NumberFormatException {
        this.value = parseByte(s, 10);
    }

    /**
     * 实现Number父类的数据类型方法,直接强转
     */
    public byte byteValue() {return value;}
    public short shortValue() {return (short)value;}
    public int intValue() {return (int)value;}
    public long longValue() { return (long)value;}
    public float floatValue() {return (float)value;}
    public double doubleValue() {return (double)value;}
    //调用Integer方法
    public String toString() {
        return Integer.toString((int)value);
    }

    //hash值为 value的int值
    @Override
    public int hashCode() {
        return Byte.hashCode(value);
    }

    public static int hashCode(byte value) {
        return (int)value;
    }

    //equals: 只有参数是Byte,并且byte值相等为true,其他为false
    public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }

    //比较大小
    public int compareTo(Byte anotherByte) {
        return compare(this.value, anotherByte.value);
    }

    public static int compare(byte x, byte y) {
        return x - y;
    } // 直接相减

    // jdk9 新增,比较无符号的两个byte 大小
    public static int compareUnsigned(byte x, byte y) {
        return Byte.toUnsignedInt(x) - Byte.toUnsignedInt(y);
    }

    /**
     * 0xff 表示为二进制就是 1111 1111。在byte类型中，代表-1(补码,除了符号位,其他取反再+1)；但在short或者int类型中则代表255
     * 当把byte类型的-1赋值到short或者int类型时(符号扩展)，虽然值仍然代表-1，但却由1111 1111变成1111 1111 1111 1111.
     * 再将其与0xff进行掩码：
     * -1: 11111111 1111111
     * 0xFF: 00000000 1111111
     * 255: 00000000 1111111
     * 所以这样，-1就转换成255.
     */
    // jdk8新增,转换为无符号的int值需要零扩展而不是符号扩展
    public static int toUnsignedInt(byte x) {
        return ((int) x) & 0xff;
    }

    // jdk8新增,转换为无符号的long值
    public static long toUnsignedLong(byte x) {
        return ((long) x) & 0xffL;
    }

    // 位数, 8位
    public static final int SIZE = 8;

    // 字节数, byte 为 1
    public static final int BYTES = SIZE / Byte.SIZE;

    private static final long serialVersionUID = -7183698231559129828L;