Short

1.Short聲明

public final class Long extends Number implements Comparable {}

復制代碼

可以看到Short類繼承了Number類，而又不是抽象類，自然要重寫Number類中的xxxValue方法。另外Short類實現了Comparable接口，Comparable是一個接口，該接口定義類的自然順序,實現該接口的類就可以按這種方式排序，一般情況下如果某類對象自身具有比較的特性就可以實現該接口，比如這里的Short代表的是一種數，而數本身就具有比較的特性，就可以實現該接口。

2.Short邊界值

public static final short MIN_VALUE = -32768;

public static final short MAX_VALUE = 32767;

復制代碼

最大值和最小值為什么是這么多，和上章Byte是一樣的，只是short為16個字節，占位2位，最大值的補碼為0111111111111111,轉換為10進制就為32767，最小值補碼為1000000000000000，十進制值為32768。

3.Short其他方法

//基本類型 short 的 Class 實例，即short.class

public static final Class TYPE = (Class) Class.getPrimitiveClass("short");

//將short類型的數轉換為其10進制對應的數的字符串形式

public static String toString(short s) {

return Integer.toString((int)s, 10);

}

//將short類型的數轉換為其指定進制對應的數的字符串形式

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;

}

//將10進制的字符串數轉換為對應的short類型的數字

public static short parseShort(String s) throws NumberFormatException {

return parseShort(s, 10);

}

//將指定進制的字符串數轉換為對應的short類型的數字

public static Short valueOf(String s, int radix)

throws NumberFormatException {

return valueOf(parseShort(s, radix));

}

//獲取字符串形式的數字，所對應的Short對象

public static Short valueOf(String s) throws NumberFormatException {

return valueOf(s, 10);

}

//Short對象的緩沖類

private static class ShortCache {

private ShortCache(){}

//緩沖數組

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

//創建緩沖對象，共256個

static {

for(int i = 0; i < cache.length; i++)

cache[i] = new Short((short)(i - 128));

}

}

//從緩沖對象中獲取對應的Short對象

//可以看到在-127到128之間是從緩存數組中取的，如果所有范圍數值都放在內存中其實比較消耗資源，所以和Byte一樣只存放了256個數值。

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

}

//將其它進制表示法，表示的字符串數據轉換為10進制表示的short數據,然后返回對應的Short對象

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數值

private final short value;

//Short類的構造器,參數為short值

public Short(short value) {

this.value = value;

}

//Short類的構造器,參數為字符串

public Short(String s) throws NumberFormatException {

this.value = parseShort(s, 10);

}

//將short數轉換為byte，由于short長度大于byte所以這里可以會出現溢出的情況

public byte byteValue() {

return (byte)value;

}

//返回short數據

public short shortValue() {

return value;

}

//將short數轉換為int類型

public int intValue() {

return (int)value;

}

//將short數轉換為long類型

public long longValue() {

return (long)value;

}

//將short數轉換為float類型

public float floatValue() {

return (float)value;

}

//將short數轉換為double類型

public double doubleValue() {

return (double)value;

}

//toString方法

public String toString() {

return Integer.toString((int)value);

}

public int hashCode() {

return Short.hashCode(value);

}

public static int hashCode(short value) {

return (int)value;

}

public boolean equals(Object obj) {

if (obj instanceof Short) {

return value == ((Short)obj).shortValue();

}

return false;

}

//比較兩個short對象的大小

public int compareTo(Short anotherShort) {

return compare(this.value, anotherShort.value);

}

public static int compare(short x, short y) {

return x - y;

}

//short類型所占的位數

public static final int SIZE = 16;

//short類型所占的字節數

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

//short的高8位與低8位互換

public static short reverseBytes(short i) {

return (short) (((i & 0xFF00) >> 8) | (i << 8));

}

//將short類型的數轉換為無符號的int類型

public static int toUnsignedInt(short x) {

return ((int) x) & 0xffff;

}

//將short類型的數轉換為無符號的long類型

public static long toUnsignedLong(short x) {

return ((long) x) & 0xffffL;

}

}

復制代碼

上述大部分方法源碼其實和Byte的是一樣的，不需要過多的說明，看看Byte的源碼就清楚了。這里不在一一說明。

4.reverseBytes(short i)

public static short reverseBytes(short i) {

return (short) (((i & 0xFF00) >> 8) | (i << 8));

}

復制代碼

這個方法在Byte中是不存在的，作用是將short類型的低8位與高8位互換的。

1.將目標數i與0xFF00(轉換為2進制是 1111 1111 0000 0000)做&的運算,得到的結果為i的高8位不變，低8位全變為0，然后右移8位，就得到了目標數i的高8位

2.將i左移8位，得到的數為一個新數,這個新數的高8位為原目標數i的低8位，這個數的低8位為0

3.將i的高8位與這個新數做|運算，得到的結果就是將目標數i的高8位，與低8位互換的數。

比如一個數的二進制為1100 0011 0101 1010

1的運算結果 0000 0000 1100 0011

2的運算結果 0101 1010 0000 0000

3的最終結果 0101 1010 1100 0011

總結

以上是生活随笔為你收集整理的java定义一个short_JDK源码解读第七章：java.lang.Short的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。