[Java源码]Short

此次咱们来看看Short的源代码，基于 jdk1.8.0_181.jdk 版本，若有错误，欢迎联系指出。

类信息

public final class Short extends Number implements Comparable<Short> 复制代码

带有final标识，也就是说不可继承的。另外继承了Number类，而Number类实现了Serializable接口，因此Integer也是能够序列化的；实现了Comparable接口。

属性

public static final int SIZE = 16;
复制代码

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

public static final int BYTES = SIZE / Byte.SIZE;
复制代码

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

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

private final short value;
复制代码

由于Short是short基本数据类型的包装类，因此这里存放了对应的值

public static final Class<Short>    TYPE = (Class<Short>) Class.getPrimitiveClass("short");
复制代码

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

private static final long serialVersionUID = 7515723908773894738L;
复制代码

内部类

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对象，避免再次实例化，提高必定的性能。

方法

构造函数

public Short(short value) {
  this.value = value;
}

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

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

parseShort 方法

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 方法

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 方法

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之间时，直接从内部类数组中换取对应对象返回；若超出缓存范围则从新实例化返回结果。因此能够看到这样的相等判断结果：

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 方法

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 方法

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 方法

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

public static int hashCode(short value) {
  return (int)value;
}
复制代码

返回自己的数值做为hashCode

equals 方法

public boolean equals(Object obj) {
  if (obj instanceof Short) {
    return value == ((Short)obj).shortValue();
  }
  return false;
}
复制代码

与输入对象进行比较，判断二者是否相等。首先判断输入对象是否为Short类型实例，而后判断二者的数值是否相等。代码逻辑上能够看出来，输入参数能够接受null值，不须要担忧NPE错误。

compare 方法

public static int compare(short x, short y) {
  return x - y;
}
复制代码

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

compareTo 方法

public int compareTo(Short anotherShort) {
  return compare(this.value, anotherShort.value);
}
复制代码

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

reverseBytes 方法

public static short reverseBytes(short i) {
  return (short) (((i & 0xFF00) >> 8) | (i << 8));
}
复制代码

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

toUnsignedInt 方法

public static int toUnsignedInt(short x) {
  return ((int) x) & 0xffff;
}
复制代码

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

toUnsignedLong 方法

public static long toUnsignedLong(short x) {
  return ((long) x) & 0xffffL;
}
复制代码

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

总结

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

最后

博客原文地址：blog.renyijiu.com/post/java源码…