Java8源码 java.lang 包 07、Byte类

概述

Byte 类将基本类型 byte 的值包装在一个对象中。一个 Byte 类型的对象只包含一个类型为 byte 的字段。

此外，该类还为 byte 和 String 的相互转换提供了几种方法，并提供了处理 byte 时非常有用的其他一些常量和方法。

类的定义

public final class Byte extends Number implements Comparable<Byte>

Byte 类继承了抽象父类 Number，并实现了 Comparable 接口的 compareTo 方法用于对象之间的比较。

静态内部类 ByteCache

    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));
        }
    }

私有的静态内部类 ByteCache，表示 Byte 缓存。其中 cache 变量在静态代码块中初始化了 -128 ~ 127 共256 个 Byte 对象。而 byte 的取值就是 -128~127。也就是说 Byte 对所有值都进行了缓存。

在其他数值类型的包装类中也有相应的缓存。取值时，先从cache中获取，如果缓存命中，则直接返回预先创建的对象；否则通过 new 创建对象。这种共享轻量级元素的方式叫做享元模式。

成员变量

    private final byte value;

用于保存 Byte 对象的值，被 final 修饰表示其初始化完成后就不能再被修改。

类变量

    // byte的边界值
	public static final byte   MIN_VALUE = -128;
    public static final byte   MAX_VALUE = 127;

	//	用于二进制补码形式表示 byte值的比特数。 
    public static final int SIZE = 8;	
	// 用于二进制补码形式表示 byte值的字节数。 
    public static final int BYTES = SIZE / Byte.SIZE;

构造方法

    public Byte(byte value) {
        this.value = value;
    }
    
    public Byte(String s) throws NumberFormatException {
        this.value = parseByte(s, 10);
    }

和 Boolean 类似，最终都是将传入的数据赋值给了 value

其他方法

toString(byte)

    public static String toString(byte b) {
        return Integer.toString((int)b, 10);
    }

注意，这不是对 Object 类中的 toString 方法进行的重写。Object 的 toString 方法没有参数。这是 Byte 类自定义的 toString 方法，它调用了 Integer 的 toString 方法将 byte 数据转换为对应的字符串形式。

parseByte(String s) 与 parseByte(String, int)

	public static byte parseByte(String s) throws NumberFormatException {
        return parseByte(s, 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;
    }

调用 Integer.parseInt(s, radix) 将合法的字符串转换为指定进制的 byte 值（默认十进制）。

上面的合法字符串要求是以十进制表示的、范围在 -128~127 的数字。即十进制的 byte 值。
下面的合法字符串要求是指定基数的、范围在 -128~127 的数字。
不合法的参数会抛出 NumberFormatException 异常：

System.out.println(Byte.parseByte("127"));		// 127
System.out.println(Byte.parseByte("7F", 16));	// 127
System.out.println(Byte.parseByte("80", 10));	// 80

//java.lang.NumberFormatException: Value out of range
System.out.println(Byte.parseByte("80", 16));	
System.out.println(Byte.parseByte("128"));

valueOf(String) 与 valueOf(String, int)

	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));
    }

等价于 parseByte 方法，其参数规则也相同。

valueOf(byte)

    public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
   }

同 Boolean 类，创建 Byte 实例时应优先使用该方法而非构造方法 Byte(byte value)，因为它走缓存，性能好。

由于数组的下标是从0开始，而byte 的取值为 -128~127，所以要加上128后才能走缓存。

重写父类的xxxValue()

	// 返回该 Byte 对象的 byte 值。
	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;
    }

除 byteValue() 方法外，其他都通过强制类型转换转换成了对应的基本类型。因为 byte 的长度最小，不会溢出。

toString()

    public String toString() {
        return Integer.toString((int)value);
    }

hashCode()

    @Override
    public int hashCode() {
        return Byte.hashCode(value);
    }

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

相当于调用了 intValue() 方法，返回的就是 Byte 对象表示的数值。

equals()

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

都是 Byte 类型，且对应的 value 值都相等，则两者是同一个对象。

compareTo() 与 compare(byte, byte)

    public int compareTo(Byte anotherByte) {
        return compare(this.value, anotherByte.value);
    }
	
	public static int compare(byte x, byte y) {
        return x - y;
    }

比较此 Byte 对象和 入参Byte 对象的数值大小。相等返回0，前者大则返回正数，后者大则返回负数。

转换成无符号整数

    public static int toUnsignedInt(byte x) {
        return ((int) x) & 0xff;
    }
    
    public static long toUnsignedLong(byte x) {
        return ((long) x) & 0xffL;
    }

见名知意，在 IO 操作时用到的情况较多。