这次我们来看看Short的源代码,基于 jdk1.8.0_181.jdk 版本,如有错误,欢迎联系指出。

类信息

1
public final class Short extends Number implements Comparable<Short>

带有final标识,也就是说不可继承的。另外继承了Number类,而Number类实现了Serializable接口,所以Integer也是可以序列化的;实现了Comparable接口。

属性

1
public static final int SIZE = 16;

表示了Short类型的bit数,16位

1
public static final int BYTES = SIZE / Byte.SIZE;

表示了Short类型的字节数,计算固定值为2

1
2
3
public static final short   MIN_VALUE = -32768;

public static final short   MAX_VALUE = 32767;
  • MIN_VALUE 表示了最小值,为-32768,即-2^15
  • MAX_VALUE 表示了最大值,为32767,即2^15 - 1
1
private final short value;

因为Shortshort基本数据类型的包装类,所以这里存放了对应的值

1
public static final Class<Short>    TYPE = (Class<Short>) Class.getPrimitiveClass("short");

获取类信息,Short.TYPE == short.class 两者是等价的

1
private static final long serialVersionUID = 7515723908773894738L;

内部类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
private static class ShortCache {
  private ShortCache(){}

  static final Short cache[] = new Short[-(-128) + 127 + 1];

  static {
    for(int i = 0; i < cache.length; i++)
      cache[i] = new Short((short)(i - 128));
  }
}

内部定义了一个长度128+127+1=256的数组,缓存了从-128~127的值。当值在这个范围中时,可以直接从数组中获取对应的Short对象,避免再次实例化,提升一定的性能。

方法

构造函数

1
2
3
4
5
6
7
public Short(short value) {
  this.value = value;
}

public Short(String s) throws NumberFormatException {
  this.value = parseShort(s, 10);
}

存在两个构造函数,支持shortString类型参数。当参数为String类型时,内部实现调用了parseShort方法,下面来看看parseShort的具体实现逻辑。

parseShort 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public static short parseShort(String s) throws NumberFormatException {
  return parseShort(s, 10);
}

public static short parseShort(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 (short)i;
}

存在两个parseShort方法,对应不同类型参数。第一个方法内部默认以十进制形式调用了第二个方法实现,所以具体来看看第二个方法的逻辑。首先调用了Integer.parseInt(s, radix)方法获取String参数对应的数值(具体此方法实现逻辑可以参考 Integer的parseInt 方法),然后判断整数是否在Short的数值范围内,是则进行类型转换返回结果;否则抛出对应的异常。

toString 方法

1
2
3
4
5
6
7
public static String toString(short s) {
  return Integer.toString((int)s, 10);
}

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

一个静态方法一个非静态方法,但是两者效果是一样的,都是以十进制形式转换获取对应的字符串结果。内部调用了Integer.toString方法实现具体逻辑,具体实现可以参考Integer的toString 方法

valueOf 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
public static Short valueOf(String s) throws NumberFormatException {
  return valueOf(s, 10);
}

public static Short valueOf(String s, int radix)
  throws NumberFormatException {
  return valueOf(parseShort(s, radix));
}

public static Short valueOf(short s) {
  final int offset = 128;
  int sAsInt = s;
  if (sAsInt >= -128 && sAsInt <= 127) { // must cache
    return ShortCache.cache[sAsInt + offset];
  }
  return new Short(s);
}

存在三个valueOf方法,主要来看看第三个方法的实现。当参数范围在-128~127之间时,直接从内部类数组中换取对应对象返回;若超出缓存范围则重新实例化返回结果。所以可以看到这样的相等判断结果:

1
2
3
4
5
6
7
8
Short a = Short.valueOf((short) 108);
Short b = Short.valueOf((short) 108);

Short c = Short.valueOf((short) 1108);
Short d = Short.valueOf((short) 1108);

System.out.println(a == b); // true
System.out.println(c == d); // false

decode 方法

1
2
3
4
5
6
7
public static Short 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((short)i);
}

这个方法主要是解码字符串转换成Short对象,支持十进制,0x, 0X, #开头的十六进制,0开头的八进制字符串。内部实现调用了Integer.decode方法获取对应的整数值(此方法可以参考Integer的decode方法),然后判断数值是否在范围内,是则调用valueOf返回对应的值;否则抛出对应的异常。

xxxValue 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public byte byteValue() {
  return (byte)value;
}

public short shortValue() {
  return 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;
}

直接进行强制类型转换,返回对应类型的数据值。

hashCode 方法

1
2
3
4
5
6
7
8
@Override
public int hashCode() {
  return Short.hashCode(value);
}

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

返回本身的数值作为hashCode

equals 方法

1
2
3
4
5
6
public boolean equals(Object obj) {
  if (obj instanceof Short) {
    return value == ((Short)obj).shortValue();
  }
  return false;
}

与输入对象进行比较,判断两者是否相等。首先判断输入对象是否为Short类型实例,然后判断两者的数值是否相等。代码逻辑上可以看出来,输入参数可以接受null值,不需要担心NPE错误。

compare 方法

1
2
3
public static int compare(short x, short y) {
  return x - y;
}

比较两个short基本数据类型值。采用了相减的判断逻辑,所以x < y时返回负数,x == y时返回0,而x > y时返回正数。

compareTo 方法

1
2
3
public int compareTo(Short anotherShort) {
  return compare(this.value, anotherShort.value);
}

比较两个Short对象值,内部调用了compare方法实现,返回值与compare方法一致。

reverseBytes 方法

1
2
3
public static short reverseBytes(short i) {
  return (short) (((i & 0xFF00) >> 8) | (i << 8));
}

以字节为单位,逆序输入参数的二进制格式。因为Short类型只有16位bit,所以逻辑比较简单,高8位和低8位采用位逻辑交换位置,然后返回对应的数值。

toUnsignedInt 方法

1
2
3
public static int toUnsignedInt(short x) {
  return ((int) x) & 0xffff;
}

通过无符号转换将参数转换成对应的int数据类型值。保留低16位的bit数据,高16位设为0。0和正数等于其自身,负数等于输入加上2^16

toUnsignedLong 方法

1
2
3
public static long toUnsignedLong(short x) {
  return ((long) x) & 0xffffL;
}

通过无符号转换将参数转换成对应的long类型数据值。保留低16位数据,高48位设为0。0和正数等于其自身,负数等于输入加上2^16

总结

总体来看,Short类型的代码是比较简单的,部分函数调用了Integer的方法实现,所以没有什么复杂逻辑。