JDK源码分析:Byte.java

  Byte是基本数据类型byte的包装类。

  1)声明部分:

public final class Byte extends Number implements Comparable<Byte> 

  实现Comparable<T>接口,实现该接口方法如下:

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

  继承Number.java,方法如下:

public abstract int intValue();  
public abstract float floatValue();  
public abstract long longValue();  
public abstract double doubleValue();  
public byte byteValue() {  
    return (byte)intValue();  
}  
public short shortValue() {  
    return (short)intValue();  
}

  其中前4个是抽象方法,Byte.java不是抽象类,所以必须实现父类的4个抽象方法;后2个方法实现调用第一个方法。Number提供了包装类型之间的强类型转换(JDK目前已经实现了自动拆箱和装箱操作)。

   2)属性部分

//min value
public static final byte MIN_VALUE = -128;
//max value public static final byte MAX_VALUE = 127; //The {@code Class} instance representing the primitive type public static final Class<Byte> TYPE = (Class<Byte>) Class.getPrimitiveClass("byte"); //The value of the {@code Byte}. private final byte value; //The number of bits used to represent a {@code byte} value in two's complement binary form. public static final int SIZE = 8; //The number of bytes used to represent a {@code byte} value in two's complement binary form. public static final int BYTES = SIZE / Byte.SIZE;

  3)私有内部静态类

//Byte Cache -128~127  
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));  
    }  
}

  含有静态模块,class加载的时候,执行静态模块,初始化cache[]。

  4)Byte的声明

  构造方法重载:

//构造方法重载1  
public Byte(byte value) {  
    this.value = value;  
}  
//构造方法重载2  
public Byte(String s) throws NumberFormatException {  
    this.value = parseByte(s, 10);  
} 

  类型转换为Byte的方法,除了构造方法和自动装箱外: 

public static Byte valueOf(byte b) {  
    final int offset = 128;  
    return ByteCache.cache[(int)b + offset];  
}  
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;  
}  
public static byte parseByte(String s) throws NumberFormatException {  
    return parseByte(s, 10);  
}  
public static Byte valueOf(String s, int radix)  
    throws NumberFormatException {  
    return valueOf(parseByte(s, radix));  
}  
public static Byte valueOf(String s) throws NumberFormatException {  
    return valueOf(s, 10);  
}  

  观察这几个方法,public static Byte valueOf(byte b)和public static byte parseByte(String s, int radix)是核心。第2个方法转换为byte;第一个方法转换为Byte,Byte根据byte的值,从缓存中获取Byte对象。

  例子:

//构造方法重载  
byte byte1 = 1;  
Byte b1 = new Byte(byte1);  
Byte b2 = new Byte("1");  
Byte b3 = byte1;//自动装箱  
out(b1==b2);//fasle  
out(b1==b3);//fasle  
//初始化方法,除构造方法和自动装箱  
Byte b4 = Byte.parseByte("1",10);//最终byte自动装箱  
Byte b5 = Byte.parseByte("1");//同上  
Byte b6 = Byte.valueOf("1",10);//最终取ByteCache  
Byte b7 = Byte.valueOf("1");//同上  
Byte b8 = Byte.valueOf(byte1);//同上  
out(b4==b2);//fasle  
out(b4==b1);//fasle  
out(b4==b3);//true  
out(b4==b5);//true  
out(b6==b7);//true  
out(b6==b8);//true  

  从例子可以得出结论:采用自动装箱会默认根据byte值去获取ByteCache,而使用构造方法重载不会去获取ByteCache,而是生成一个新的对象,所以byte声明的时候,要采用直接装箱,或者除了new一个对象以外的方法。
  5)其他方法:

public static String toString(byte b) {  
    return Integer.toString((int)b, 10);  
}  
public String toString() {  
    return Integer.toString((int)value);  
}  
  
//decode 解码,将(2,8,16)进制转换为十进制  
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);  
}  
  
@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;  
}  
  
public static int toUnsignedInt(byte x) {  
    return ((int) x) & 0xff;  
}  
public static long toUnsignedLong(byte x) {  
    return ((long) x) & 0xffL;  
}  

  例子:

//其他方法  
Byte.toString(byte1);//1  
b8.toString();//1  
b8.hashCode();//1  
Byte.decode("0x8");//8  
b4.equals(b2);//true  
byte byte2 = -1;  
Byte.toUnsignedInt(byte1);//1  
Byte.toUnsignedLong(byte1);//1  
Byte.toUnsignedInt(byte2);//255 强转为int的-1,-1的二进制补码:1111,1111,1111,1111,1111,1111,1111,1111,进行& 0xff,截取byte表示8位以外的其他高位。  
Byte.toUnsignedLong(byte2);//255  

  

posted @ 2018-05-13 15:56  knbsyoo  阅读(203)  评论(0编辑  收藏  举报