从JDK源码角度看Short

时间 2019-11-17

标签 jdk 源码角度 short 栏目 Java 繁體版

原文原文链接

概况

Java的Short类主要的做用就是对基本类型short进行封装，提供了一些处理short类型的方法，好比short到String类型的转换方法或String类型到short类型的转换方法，固然也包含与其余类型之间的转换方法。html

继承结构

--java.lang.Object
  --java.lang.Number
    --java.lang.Short复制代码

主要属性

public static final short   MIN_VALUE = -32768;

public static final short   MAX_VALUE = 32767;

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

public static final int SIZE = 16;

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

MIN_VALUE静态变量表示short能去的最小值，为-32768（-2的15此方），被final修饰说明不可变。
相似的还有MAX_VALUE，表示short最大值为32767（2的15次方减1）。
SIZE用来表示二进制补码形式的short值的比特数，值为16，静态变量且不可变。
BYTES用来表示二进制补码形式的short值的字节数，值为SIZE除于Byte.SIZE，结果为2。
TYPE的toString的值是short。
Class的getPrimitiveClass是一个native方法，在Class.c中有个Java_java_lang_Class_getPrimitiveClass方法与之对应，因此JVM层面会经过JVM_FindPrimitiveClass函数会根据"short"字符串得到jclass，最终到Java层则为Class<Short>。

JNIEXPORT jclass JNICALL
Java_java_lang_Class_getPrimitiveClass(JNIEnv *env,
                                       jclass cls,
                                       jstring name)
{
    const char *utfName;
    jclass result;

    if (name == NULL) {
        JNU_ThrowNullPointerException(env, 0);
        return NULL;
    }

    utfName = (*env)->GetStringUTFChars(env, name, 0);
    if (utfName == 0)
        return NULL;

    result = JVM_FindPrimitiveClass(env, utfName);

    (*env)->ReleaseStringUTFChars(env, name, utfName);

    return result;
}复制代码

当TYPE执行toString时，逻辑以下，则实际上是getName函数决定其值，getName经过native方法getName0从JVM层获取名称，java

public String toString() {
        return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
            + getName();
    }复制代码

getName0根据一个数组得到对应的名称，JVM根据Java层的Class可获得对应类型的数组下标，好比这里下标为9，则名称为"short"。数组

const char* type2name_tab[T_CONFLICT+1] = {
  NULL, NULL, NULL, NULL,
  "boolean",
  "char",
  "float",
  "double",
  "byte",
  "short",
  "int",
  "long",
  "object",
  "array",
  "void",
  "*address*",
  "*narrowoop*",
  "*conflict*"
};复制代码

主要方法

parseShort方法

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;
}
public static short parseShort(String s) throws NumberFormatException {
        return parseShort(s, 10);
}复制代码

两个parseShort方法，主要看第一个便可，第一个参数是待转换的字符串，第二个参数表示进制数，这里的转换实际上是调了Integer的parseInt方法，返回值再判断是否是在short的最小值和最大值之间。怎么更好理解这个参数呢？举个例子，Short.parseShort("100",10)表示十进制的100，因此值为100，而Short.parseShort("100",2)表示二进制的100，因此值为4。另外若是Short.parseShort("100000",10)会抛出java.lang.NumberFormatException异常。缓存

构造函数

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

public Short(short value) {
    this.value = value;
}复制代码

包含两种构造函数，分别能够传入short和String类型。它是经过调用parseShort方法进行转换的，因此转换逻辑与上面的parseShort方法同样。bash

toString方法

public static String toString(short s) {
    return Integer.toString((int)s, 10);
}
public String toString() {
   return Integer.toString((int)value);
}复制代码

一个是静态方法一个是非静态方法，但两个方法转换的效果是同样的，都是以十进制形式转换。并发

ShortCache内部类

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));
    }
}复制代码

ShortCache是Short的一个内部类，它包含了short可能值的Short数组，范围是[-128,127]，它不会像Byte类将全部可能值缓存起来，由于Short类型范围很大，将它们所有缓存起来代价过高，而Byte类型就是从-128到127，一共才256个。因此这里只实例化256个Short对象，当Short的值范围在[-128,127]时则直接从缓存中获取对应的Short对象，没必要从新实例化。固然这些缓存值都是静态且final的，避免重复的实例化和回收。函数

valueOf方法

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方法，主要看上面这个，由于ShortCache缓存了[-128,127]值的Short对象，对于在范围内的直接从ShortCache的数组中获取对应的Short对象便可，而在范围外的则须要从新实例化了。oop

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);
}复制代码

decode方法主要做用是解码字符串转成Short型，好比Short.decode("11")的结果为11，而Short.decode("0x11")结果为17，由于后面的是十六进制，它会根据实际状况进行解码。优化

xxxValue方法

包括shortValue、intValue、longValue、byteValue、floatValue和doubleValue等方法，其实就是转换成对应的类型。ui

hashCode方法

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

hashCode方法很简单，就是直接返回int类型的值。

equals方法

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

比较是否相同时先判断是否是Short类型再比较值。

compare方法

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

经过相减来比较，大于0则说明x大于y。

无符号转换

public static int toUnsignedInt(short x) {
    return ((int) x) & 0xffff;
}

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

包括转成无符号int型和无符号long型。

如下是广告和相关阅读

========广告时间========

鄙人的新书《Tomcat内核设计剖析》已经在京东销售了，有须要的朋友能够到 item.jd.com/12185360.ht… 进行预约。感谢各位朋友。

为何写《Tomcat内核设计剖析》

=========================