[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源碼…