JDK1.8源码学习--lang包(Short)

前言

 
月是一轮明镜,晶莹剔透,代表着一张白纸(啥也不懂)

央是一片海洋,海乃百川,代表着一块海绵(吸纳万物)

泽是一柄利剑,千锤百炼,代表着千百锤炼(输入输出)

月央泽,学习的一种过程,从白纸->吸收各种知识->不断输入输出变成自己的内容

希望大家一起坚持这个过程,也同样希望大家最终都能从零到零,把知识从薄变厚,再由厚变薄!
 

一.Short的作用:

         直接看源码注释(我的翻译可能不太准,如果道友们有更棒的理解,可以留言或者私信)

/**
 * The {@code Short} class wraps a value of primitive type {@code
 * short} in an object.  An object of type {@code Short} contains a
 * single field whose type is {@code short}.
 * 1.Short类将原始类型 short的值包装在一个对象中。 Short类型的对象包含一个类型为short的字段。
 * <p>In addition, this class provides several methods for converting
 * a {@code short} to a {@code String} and a {@code String} to a
 * {@code short}, as well as other constants and methods useful when
 * dealing with a {@code short}.
 * 2.此外，该类提供了几种将 short转换为String和将 String转换为short的方法，以及其他在处理short时有用的常量和方法。
 * @author  Nakul Saraiya
 * @author  Joseph D. Darcy
 * @see     java.lang.Number
 * @since   JDK1.1
 */

二.Short的类图:

 

    a).一个Comparable,这个接口对实现他的每个对象都可按照一定的规则来进行排序,详情请点击下面链接

         JDK1.8源码学习--lang包(Comparable)_w5_Silence的博客-CSDN博客

    b).Secializable,这个接口是可为实现的对象进行序列化,详情请点击下面链接
                  ......(假装这个是链接,以后补充)

    c).Numer,这个抽象类对一些数字操作进行了相关规范

       JDK1.8源码学习--lang包(Number)_w5_Silence的博客-CSDN博客

 三.成员变量:

 /**
     * 保持short可以具有的最小值的常量，-2<sup>15<sup
     */
    public static final short   MIN_VALUE = -32768;

    /**
     * 保持 short 可以具有的最大值的常量，2<sup>15<sup>-1
     */
    public static final short   MAX_VALUE = 32767;

    /**
     * 表示原始类型short的Class实例。
     */
    @SuppressWarnings("unchecked")
    public static final Class<Short>    TYPE = (Class<Short>) Class.getPrimitiveClass("short");

   /**
     * Short的值。
     */
    private final short value;

    /**
     * 用于以二进制补码形式表示 short值的位数。
     */
    public static final int SIZE = 16;

    /**
     * 用于以二进制补码形式表示short值的字节数
     */
    public static final int BYTES = SIZE / Byte.SIZE;

四.构造方法: 

    /**
     * 构造一个新分配的 Short对象，表示指定的short值。
     */
    public Short(short value) {
        this.value = value;
    }

    /**
     * 构造一个新分配的Short对象，该对象表示由String参数指示的short值。
     * 字符串按照 parseShort方法用于基数 10 的方式完全转换为short值。
     */
    public Short(String s) throws NumberFormatException {
        this.value = parseShort(s, 10);
    }

五.内部方法: 

                toString

   /**
     * 返回一个新的 String对象，表示指定的 short。假设基数为 10。
     */
    public static String toString(short s) {
        return Integer.toString((int)s, 10);
    }

    /**
     * 1.返回表示此 Short值的String对象。该值被转换为有符号十进制表示并作为字符串返回，
     * 就像short值作为参数提供给java.lang.Short.toString(short)方法一样。
     */
    public String toString() {
        return Integer.toString((int)value);
    }

                parseShort

    /**
     * 1.将字符串参数解析为第二个参数指定的基数中的带符号short。
     * 字符串中的字符必须都是指定基数的数字（由 java.lang.Character.digit(char, int)是否返回非负值决定），
     * 但第一个字符可以是 ASCII 减号 '-'表示负值或 ASCII 加号  '+'表示正值。返回结果 short值。
     * 2.如果发生以下任何一种情况，则会抛出 NumberFormatException类型的异常：第一个参数是null或长度为零的字符串。
     * 3.基数小于 java.lang.CharacterMIN_RADIX或大于java.lang.CharacterMAX_RADIX
     * 4.字符串中的任何字符都不是指定基数的数字，除了第一个字符可以是减号'-'或加号'+' 前提是字符串的长度大于长度 1。
     * 5.字符串表示的值不是 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;
    }

    /**
     * 1.将字符串参数解析为有符号十进制 short。字符串中的字符必须都是十进制数字，
     * 除了第一个字符可以是ASCII减号'-'表示负值或ASCII加号'+'表示正值。返回结果short值，
     * 就像参数和基数 10 作为参数提供给 parseShort(java.lang.String, int)方法一样
     */
    public static short parseShort(String s) throws NumberFormatException {
        return parseShort(s, 10);
    }

                valueOf

    /**
     * 1.返回一个Short对象，其中包含使用第二个参数给出的基数解析时从指定的String中提取的值。
     * 第一个参数被解释为表示由第二个参数指定的基数中的有符号short，
     * 就像参数被提供给parseShort(java.lang.String, int)方法一样。结果是一个Short对象，
     * 表示由字符串指定的short值。
     * 2.换句话说，此方法返回一个Short对象，其值等于：new Short(Short.parseShort(s, radix))
     */
    public static Short valueOf(String s, int radix)
        throws NumberFormatException {
        return valueOf(parseShort(s, radix));
    }

    /**
     * 1.返回一个Short对象，其中包含由指定的String给出的值。参数被解释为表示一个带符号的十进制short，
     * 就像参数被提供给parseShort(java.lang.String)方法一样。结果是一个Short对象，表示由字符串指定的short值。
     * 2.换句话说，此方法返回一个Short对象，其值等于：new Short(Short.parseShort(s))
     */
    public static Short valueOf(String s) throws NumberFormatException {
        return valueOf(s, 10);
    }

  /**
     * 1.返回表示指定的short值的Short实例
     *  2.如果不需要新的Short实例，则通常应优先使用此方法而不是构造函数Short(short)，
     *  因为此方法可能会通过缓存频繁请求的内容来显着提高空间和时间性能值。

     * 3.此方法将始终缓存 -128 到 127（含）范围内的值，并且可能缓存此范围之外的其他值
     */
    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);
    }

                decode

    /**

     * 1.将 String解码为 Short。接受语法给出的十进制、十六进制和八进制数

     * 2.DecimalNumeral,HexDigits 和 <i>OctalDigits在Java™ 语言规范的 3.10.1 节中定义，但数字之间不接受下划线
     * 3.可选符号和/或基数说明符（“0x”、“0X”、“#”或前导零）之后的字符序列被解析为Short.parseShort
     * 具有指定基数（10、16 或 8）的方法。此字符序列必须表示正值，否则将抛出NumberFormatException。
     * 如果指定的 String的第一个字符是减号，则结果否定。String中不允许出现空白字符
     */
    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);
    }

                不同值间相互转换

    /**
     * 1.在缩小原始转换后，将此 Short的值作为byte返回
     */
    public byte byteValue() {
        return (byte)value;
    }

    /**
     * 将此Short的值作为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;
    }

                        hashCode

    /**
     * 返回此Short的哈希码；等于调用 intValue()的结果
     */
    @Override
    public int hashCode() {
        return Short.hashCode(value);
    }

    /**
     * 返回 short值的哈希码；与 Short.hashCode()兼容。
     */
    public static int hashCode(short value) {
        return (int)value;
    }

                equals

    /**
     * 将此对象与指定的对象进行比较。结果是 true当且仅当参数不是 null并且
     * 是包含与此对象相同的 short值的 Short对象。
     */
    public boolean equals(Object obj) {
        if (obj instanceof Short) {
            return value == ((Short)obj).shortValue();
        }
        return false;
    }

                compare

    /**
     * 以数字方式比较两个Short对象
     */
    public int compareTo(Short anotherShort) {
        return compare(this.value, anotherShort.value);
    }

    /**
     * 以数字方式比较两个short值。返回的值与以下返回的值相同：Short.valueOf(x).compareTo(Short.valueOf(y))
     */
    public static int compare(short x, short y) {
        return x - y;
    }

                reverseBytes

    /**
     * 1.返回通过反转指定short值的二进制补码表示中的字节顺序而获得的值
     */
    public static short reverseBytes(short i) {
        return (short) (((i & 0xFF00) >> 8) | (i << 8));
    }

                toUnsignenInt/long

    /**
     * 1.通过无符号转换将参数转换为 int。在到int的无符号转换中，int的高 16 位为零，
     * 低 16 位等于 short参数的位。
     * 2.因此，零和正 short值被映射到一个数值上相等的 int值，而负 short值被映射
     * 到一个int值等于输入加上 2<sup> 16<sup>
     */
    public static int toUnsignedInt(short x) {
        return ((int) x) & 0xffff;
    }

    /**
     * 1.通过无符号转换将参数转换为 long。在到 long的无符号转换中，long的高 48 位为零，
     * 低 16 位等于  short参数的位。
     * 2.因此，零和正 short值被映射到一个数值相等的long值，负 short值被映射
     * 到一个 long值等于输入加上 2<sup> 16<sup>。
     */
    public static long toUnsignedLong(short x) {
        return ((long) x) & 0xffffL;
    }

六.总结

         Short 也算是比较轻松的一个基础类型的包装类了...