每日一类-Byte类

概述

        Byte 类是基本数据类型byte的包装类，也可以Byte类是对byte类型的封装类，对byte类型操作进行功能性拓展，拓展出平常开发常用到的功能，比如：intValue，valueOf，compareTo等。

源码

/**
 * Byte
 * 1>继承 Number 类，表面Byte类是数字类类，后续要重写 Number类6个抽象方法
 *   intValue  longValue  floatValue  doubleValue  byteValue shortValue
 * 2>实现  Comparable 接口，重写 compareTo 方法，让Byte称为可比较的类，默认是正序比较
 */
public final class Byte extends Number implements Comparable<Byte> {

    //最小值常量：byte 类型最小取值
    public static final byte   MIN_VALUE = -128;
    //最大值常量：byte 类型最大取值
    public static final byte   MAX_VALUE = 127;

    //字节码对象类型，使用byte识别为基本数据类型的包装类型
    @SuppressWarnings("unchecked")
    public static final Class<Byte>     TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");

    //字符串打印，以10进制格式打印
    public static String toString(byte b) {
        return Integer.toString((int)b, 10);
    }

    //享元模式设计start-----------------------------------------------------
    private static class ByteCache {
        private ByteCache(){}
        static final Byte cache[] = new Byte[-(-128) + 127 + 1];
        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Byte((byte)(i - 128));
        }
    }
    //@HotSpotIntrinsicCandidate
    public static Byte valueOf(byte b) {
        final int offset = 128;
        return Byte.ByteCache.cache[(int)b + offset];
    }
    //享元模式设计end-----------------------------------------------------

    /**
     * 将传入内容为数值类型的字符串，根据指定进制转换成byte类型数据
     * 参数1：内容为数值类型的字符串
     * 参数2：进制
     *
     * eg：
     *  byte ret = Byte.parseByte("11", 2);  //ret = 3
     *  byte ret = Byte.parseByte("11", 10);  //ret = 10
     *
     */
    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;
    }

    //不指定进制，默认是10进制
    public static byte parseByte(String s) throws NumberFormatException {
        return parseByte(s, 10);
    }

    /**
     * 将传入内容为数值类型的字符串，根据指定进制转换成Byte类型对象
     * 参数1：内容为数值类型的字符串
     * 参数2：进制
     *
     * 跟上面parseByte 方法一样，区别是当前方法返回是Byte对象
     *
     * byte ret = Byte.parseByte("11", 2);
     * Byte ret = Byte.valueOf("11", 2);
     *
     */
    public static Byte valueOf(String s, int radix)
            throws NumberFormatException {
        return valueOf(parseByte(s, radix));
    }
    //不指定进制，默认是10进制
    public static Byte valueOf(String s) throws NumberFormatException {
        return valueOf(s, 10);
    }

    //将传入内容为数值类型的字符串，转换成Byte类型对象，此次借助的是Integer实现， 默认是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 类跟 byte类型 存在自动装箱与拆箱相互转换的功能
    //value 就是Byte类对byte数值的存储值
    private final byte value;

    //构造器，jdk9之后，不建议使用了
    @Deprecated(since="9")
    public Byte(byte value) {
        this.value = value;
    }

    //构造器，jdk9之后，不建议使用了
    @Deprecated(since="9")
    public Byte(String s) throws NumberFormatException {
        this.value = parseByte(s, 10);
    }

    //Number类方法重写start----------------------------------
    //@HotSpotIntrinsicCandidate
    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;
    }
    //Number类方法重写end--------------------------------

    //转换成字符串
    public String toString() {
        return Integer.toString((int)value);
    }

    //hashCode equals方法重写start---------------------
    @Override
    public int hashCode() {
        return Byte.hashCode(value);
    }
    public static int hashCode(byte value) {
        return (int)value;
    }
    public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }
    //hashCode equals方法重写end---------------------

    //接口Comparable 方法重写
    public int compareTo(Byte anotherByte) {
        return compare(this.value, anotherByte.value);
    }
    public static int compare(byte x, byte y) {
        return x - y;
    }

    //无符号比较，之比较值，不比较符号
    public static int compareUnsigned(byte x, byte y) {
        return Byte.toUnsignedInt(x) - Byte.toUnsignedInt(y);
    }
    public static int toUnsignedInt(byte x) {
        return ((int) x) & 0xff;
    }
    public static long toUnsignedLong(byte x) {
        return ((long) x) & 0xffL;
    }
    //指定字节位数
    public static final int SIZE = 8;
    //指定byte类型占有几个字节
    public static final int BYTES = SIZE / Byte.SIZE;
    //系列化id
    private static final long serialVersionUID = -7183698231559129828L;
}

解析

源码里面有个比较有意思的设计：享元模式设计，详细解释前，先看一个小案例

Byte b1 = 100;
Byte b2 = new Byte("100");
Byte b3 = 100;
Byte b4 = Byte.valueOf("100");
Byte b5 = new Byte("100");
System.out.println(b1 == b2); //false
System.out.println(b1 == b3); //true
System.out.println(b2 == b3); //false
System.out.println(b1 == b4); //true
System.out.println(b1 == b5); //false
System.out.println(b2 == b5); //false

从上面打印结果可以看出b1 == b3 == b4     b2 !=  b5 != b1  为什么呢？ 

b2 b5 不等，很好理解，就是new出来的对象，内存地址必定不一样，这个好理解，那b1 == b3 == b4  怎么理解？ 那秘密就在下面的代码里面。

//享元模式设计start-----------------------------------------------------
private static class ByteCache {
    private ByteCache(){}
    static final Byte cache[] = new Byte[-(-128) + 127 + 1];
    static {
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Byte((byte)(i - 128));
    }
}
//@HotSpotIntrinsicCandidate
public static Byte valueOf(byte b) {
    final int offset = 128;
    return Byte.ByteCache.cache[(int)b + offset];
}
//享元模式设计end-----------------------------------------------------

byte类型有2个常识：

1>byte常量是可以跟 Byte包装类自动完成装箱与拆箱的操作，

        自动装箱： Byte b = 100    底层实现了：    Byte.valueOf((byte) 100);

        自动拆箱 byte bb = b          底层实现了：    byte bb = b.byteValue()

2>byte类型取值范围 【-128,127】

Byte类中定义一个静态内部类ByteCache ，内部持有一个Byte类型数组，数组中缓存数值为-128到+127所有Byte对象，当自动装箱时(调用valueOf方法)，会从静态内部缓存数组获取。所以小案例中的b1 == b3 == b4  相等，就是因为b1，b3，b4获取是同一个Byte对象。