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