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