Long源码分析。

以你之姓@ 2024-02-19 15:17 3阅读 0赞

public final class Long extends Number implements Comparable<Long> {
        /*
         * 继承Number类提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法。<br />
         * 实现Comparable接口，获取到compareTo方法。
         */
        // 保持 long 类型的最小值的常量，该值为 -2的63方
        public static final long MIN_VALUE = 0x8000000000000000L;
        // 保持 long 类型的最大值的常量，该值为 2的63方-1
        public static final long MAX_VALUE = 0x7fffffffffffffffL;
        // 表示基本类型 long 的 Class 实例
        public static final Class<Long>     TYPE = (Class<Long>) Class.getPrimitiveClass("long");
    	/**
    	 * 转化对应进制的数字为十进制
    	 * @param i	要转换为字符串的 long
    	 * @param radix	进制数
    	 * @return String 
    	 */
        public static String toString(long i, int radix) {
            // 如果进制数小于2进制 或者大于 26进制，则改用十进制。 
            if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
                radix = 10;
            /* 如果是十进制，用最快的版本 */
            if (radix == 10)
                return toString(i);
            // 创建一个65位的字符数组(负数时:1位符号位+64位数字；正数时,64位数字)
            char[] buf = new char[65];
            int charPos = 64;
            boolean negative = (i < 0);
            // 将正数转为负数进行运算，防止负数转为正数的溢出情况
            if (!negative) {
                i = -i;
            }
            // 循环判断当前转换的字符是否小于计数的相反数
            while (i <= -radix) {
                //根据余数的相反数在digits数组中获取相应的字符，倒序存放到buf[]数组里
                buf[charPos--] = Integer.digits[(int)(-(i % radix))];
                i = i / radix;
            }   
            buf[charPos] = Integer.digits[(int)(-i)];
            // 若是负数，加减号
            if (negative) {
                buf[--charPos] = '-';
            }
            // 返回一个字符串，参数为char数组、起始位置、字符长度
            return new String(buf, charPos, (65 - charPos));
        }
    	/**
    	 * 返回当前long的16进制的字符串形式
    	 * @param i	要转换为字符串的 long
    	 * @return String 
    	 */
        public static String toHexString(long i) {
            return toUnsignedString(i, 4);
        }
        /**
         * 返回当前long的8进制的字符串形式
         * @param i	要转换为字符串的 long
         * @return String 
         */
        public static String toOctalString(long i) {
            return toUnsignedString(i, 3);
        }
        /**
         * 返回当前long的2进制的字符串形式
         * @param i	要转换为字符串的 long
         * @return String 
         */
        public static String toBinaryString(long i) {
            return toUnsignedString(i, 1);
        }
        /**
         * 返回当前long类型的i的shift进制的字符串形式的私有工具类
         * @param i
         * @param shift	进制数
         * @return String 
         */
        private static String toUnsignedString(long i, int shift) {
            char[] buf = new char[64];
            int charPos = 64;
            // 算数左移，radix中间变量用于计算mask
            int radix = 1 << shift;
            // mask掩码用于获取i的shift位低位，mask二进制数每一位都是1
            long mask = radix - 1;
            do {
                //取出i二进制数低位shift位，将对应的字符存入buf
                buf[--charPos] = Integer.digits[(int)(i & mask)];
                //逻辑右移，剔除已取出的shfit位低位
                i >>>= shift;
            } while (i != 0);
            return new String(buf, charPos, (64 - charPos));
        }
        /**
         * 返回当前long的字符串形式
         * @param i
         * @return String 
         */
        public static String toString(long i) {
            if (i == Long.MIN_VALUE)
                return "-9223372036854775808";
            // 判断是否为负数，计算长度
            int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
            char[] buf = new char[size];
            // 将数字分成一个个char，保存到buf数组中
            getChars(i, size, buf);
            return new String(buf, true);
        }
        /**
         * 将某个long型数值写入到字符数组中（若i等于Long.MIN_VALUE,则为失败）
         * 几种运算的耗时长短:除法运算>乘法运算>移位结合加法的运算
         * @param i	long型数值
         * @param index	长度
         * @param buf buf数组
         * @return void 
         */
        static void getChars(long i, int index, char[] buf) {
            long q;
            int r;
            int charPos = index;
            char sign = 0;
            // 负数的处理
            if (i < 0) {
                sign = '-';
                i = -i;
            }
            // i大于int最大值
            while (i > Integer.MAX_VALUE) {
                q = i / 100;
                // really: r = i - (q * 100);
                r = (int)(i - ((q << 6) + (q << 5) + (q << 2)));
                // 将商赋给i，继续循环，直到小于2147483647 
                i = q;
                // 取DigitOnes[r]的值其实取数字r%10的结果
                buf[--charPos] = Integer.DigitOnes[r];
                // 取DigitTens[r]的值其实取数字r/10的结果
                buf[--charPos] = Integer.DigitTens[r];
            }
            // i大于等于65536，16次方
            int q2;
            int i2 = (int)i;
            while (i2 >= 65536) {
                q2 = i2 / 100;
                // really: r = i2 - (q * 100);
                r = i2 - ((q2 << 6) + (q2 << 5) + (q2 << 2));
                // 将商赋给i，继续循环，直到小于65536
                i2 = q2;
                // 取DigitOnes[r]的值其实取数字r%10的结果
                buf[--charPos] = Integer.DigitOnes[r];
                // 取DigitTens[r]的值其实取数字r/10的结果
                buf[--charPos] = Integer.DigitTens[r];
            }
            // 对于较小的数字，进入快速模式
            // 循环存放低两字节的数字存放到字符数组中空余位置
            for (;;) {
                // 右移19位
                /**
                 * >>>: 无符号的右移
                 * >>: 有符号的右移
                 */
                q2 = (i2 * 52429) >>> (16+3);
                r = i2 - ((q2 << 3) + (q2 << 1));  // r = i2-(q2*10) ...
                // 从digit数组中取数
                buf[--charPos] = Integer.digits[r];
                i2 = q2;
                //整数写入字符数组完成
                if (i2 == 0) break;
            }
                //整数写入字符数组完成
            if (sign != 0) {
                buf[--charPos] = sign;
            }
        }
        /**
         * 判断一个long类型数字的长度
         * @param x	long类型的整数
         * @return int 
         */
        static int stringSize(long x) {
            long p = 10;
            for (int i=1; i<19; i++) {
                if (x < p)
                    return i;
                p = 10*p;
            }
            return 19;
        }
        /**
         * 返回输入字符串的指定进制的long值
         * @param s	
         * @param radix	进制数
         * @throws NumberFormatException 
         * @return long 
         */
        public static long parseLong(String s, int radix)
                  throws NumberFormatException
        {
            if (s == null) {
                throw new NumberFormatException("null");
            }
    
            if (radix < Character.MIN_RADIX) {
                throw new NumberFormatException("radix " + radix +
                                                " less than Character.MIN_RADIX");
            }
            if (radix > Character.MAX_RADIX) {
                throw new NumberFormatException("radix " + radix +
                                                " greater than Character.MAX_RADIX");
            }
          // 保存结果 
            long result = 0;
          // 判断正负
            boolean negative = false;
            int i = 0, len = s.length();
            long limit = -Long.MAX_VALUE;
            long multmin;
            int digit;
    
            if (len > 0) {// 字符串的长度大于零
                // 取第一个值
                char firstChar = s.charAt(0);
                if (firstChar < '0') { // 如果第一个字符小于0 
                    if (firstChar == '-') {// 为负数
                        negative = true;
                        limit = Long.MIN_VALUE;
                    } else if (firstChar != '+')//不为正数
                        throw NumberFormatException.forInputString(s);
    
                    if (len == 1) // 不能只有一个符号
                        throw NumberFormatException.forInputString(s);
                    i++;
                }
                // 限制的最小值(在对应进制的)
                multmin = limit / radix;
                // 将字符串的数字部分转为进制的数字(从左到右)
                while (i < len) {
                    // 将字符串的数字部分的一个数字(对应进制)，通过Character类转为进制的数
                    // 若字符串中的某一个字符，在字符串进制下(radix)是无效的，则返回-1
                    digit = Character.digit(s.charAt(i++),radix);
                    if (digit < 0) {// 若返回-1(无效)
                        throw NumberFormatException.forInputString(s);
                    }
                    if (result < multmin) {// 结果小于最小的值(目标进制下)
                        throw NumberFormatException.forInputString(s);
                    }
                    // 结果：将结果乘上字符串进制数
                    result *= radix;
                    // 若结果小于最小值加上当前最字符值
                    if (result < limit + digit) {
                        throw NumberFormatException.forInputString(s);
                    }
                    // 将结果减去当前字符的值
                    result -= digit;
                }
            } else {
                throw NumberFormatException.forInputString(s);
            }
            // 若是负数，则直接返回，若是正数，先取反结果再输出
            return negative ? result : -result;
        }
        /**
         * 返回指定字符串的long类型的数值，默认是10进制的
         * @param s	long类型的数值
         * @throws NumberFormatException 
         * @return long 
         */
        public static long parseLong(String s) throws NumberFormatException {
            return parseLong(s, 10);
        }
        /**
         * 返回指定转换进制的字符串的一个Long对象
         * @param s	需要转换的字符串
         * @param radix	进制数
         * @throws NumberFormatException 
         * @return Long 
         */
        public static Long valueOf(String s, int radix) throws NumberFormatException {
            return Long.valueOf(parseLong(s, radix));
        }
        /**
         * 返回指定字符串的一个Long对象，默认是10进制的
         * @param s	需要转换的字符串
         * @throws NumberFormatException 
         * @return Long 
         */
        public static Long valueOf(String s) throws NumberFormatException
        {
            return Long.valueOf(parseLong(s, 10));
        }
        /**
         * 缓存以支持自动装箱的对象标识语义.用于在-128和127
         * 缓存在第一次使用时被初始化。
         */
        private static class LongCache {
            private LongCache(){}
    
            static final Long cache[] = new Long[-(-128) + 127 + 1];
    
            static {
                for(int i = 0; i < cache.length; i++)
                    cache[i] = new Long(i - 128);
            }
        }
        /**
         * 返回表示指定 long 值的 Long 实例。
         * 如果不需要新的 Long 实例，则通常优先使用此方法，
         * 而不是使用构造方法 Long(long)，
         * 因为此方法通过缓存频繁请求的值，
         * 可以显著提高时间和空间性能。 
         * @param l
         * @return Long 
         */
        public static Long valueOf(long l) {
            final int offset = 128;
            // 直接获得在[-128,127]范围内的LongCache缓存的对象，不在该范围则重新实例化Integer对象
            if (l >= -128 && l <= 127) { // will cache
                return LongCache.cache[(int)l + offset];
            }
            return new Long(l);
        }
        /**
         *  将 String 解码成 Long
         * @param nm	字符串
         * @throws NumberFormatException 
         * @return Long 
         */
        public static Long decode(String nm) throws NumberFormatException {
        	// 10进制
            int radix = 10;
            int index = 0;
            // 正负数标识
            boolean negative = false;
            Long result;
    
            if (nm.length() == 0)
                throw new NumberFormatException("Zero length string");
            // 获取第一个字符
            char firstChar = nm.charAt(0);
            if (firstChar == '-') {// 为负数
                negative = true;
                index++;
            } else if (firstChar == '+')// 为正数
                index++;
            // 然后剩下的字符串以0x或0X开头，表示十六进制
            if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
                index += 2;
                radix = 16;
            }
            else if (nm.startsWith("#", index)) {// 或以#开头，表示十六进制
                index ++;
                radix = 16;
            }
            //若以0开头，且字符串长度大于当前判断字符数+1,则为8进制
            else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
                index ++;
                radix = 8;
            }
            // 再存在"-"/"+"这两字符，则抛出数字转化异常
            if (nm.startsWith("-", index) || nm.startsWith("+", index))
                throw new NumberFormatException("Sign character in wrong position");
            try {
                // 将剩下的字符串从某进制转为指定进制的数的包装类对象
                result = Long.valueOf(nm.substring(index), radix);
                // 若是负数,取反包装类Long中的value的值,再进行获取该基本数据类型的包装对象实例
                result = negative ? Long.valueOf(-result.longValue()) : result;
            } catch (NumberFormatException e) {
                // 使用long类型参数转化出现异常，转而使用String类型参数进行转化
                String constant = negative ? ("-" + nm.substring(index))
                                           : nm.substring(index);
                // 转化字符串成对应的包装类的实例对象
                result = Long.valueOf(constant, radix);
            }
            return result;
        }
        // 保存Long类中的真实基本数据类型的值
        private final long value;
        /**
         * 构造一个新分配的 Long 对象，它表示指定的 long 值。
         * @param value 
         */
        public Long(long value) {
            this.value = value;
        }
        /**
         * 构造新分配的 Long 对象，表示由 String 参数指示的 long 值。
         * 该字符串被转换为 long 值，
         * 其方式与 radix 参数为 10 的 parseLong 方法所使用的方式一致。 
         * @param s	要转换为 Long 的 String
         * @throws NumberFormatException 
         * @return void 
         */
        public Long(String s) throws NumberFormatException {
            this.value = parseLong(s, 10);
        }
        /**
         * 以 byte 类型返回该 Long 的值。
         */
        public byte byteValue() {
            return (byte)value;
        }
        /**
         * 以 short 类型返回该 Integer 的值。 
         */
        public short shortValue() {
            return (short)value;
        }
        /**
         * 以 int 类型返回该 Integer 的值。
         */
        public int intValue() {
            return (int)value;
        }
    	/**
    	 * 以 long 类型返回该 Integer 的值。 
    	 */
        public long longValue() {
            return (long)value;
        }
    	/**
    	 * 以 float 类型返回该 Integer 的值。 
    	 */
        public float floatValue() {
            return (float)value;
        }
    	/**
    	 * 以 double 类型返回该 Integer 的值。 
    	 */
        public double doubleValue() {
            return (double)value;
        }
    	/**
    	 * 返回表示 Long 值的 String 对象。
    	 * 该值被转换为有符号十进制表示形式，并作为字符串返回，
    	 * 该字符串与用 long 值作为参数的 toString(long) 方法
    	 * 得到的字符串非常相似。 
    	 */
        public String toString() {
            return toString(value);
        }
        /**
         * 返回 Long 的哈希码。
         * 结果是此 Long 对象保持的基本 long 值的两个部分的异或 (XOR)。
         */
        public int hashCode() {
            return (int)(value ^ (value >>> 32));
        }
        /**
         * 比较此对象与指定对象。当且仅当参数不为 null，
         * 并且是一个与该对象包含相同long 值的 Integer 对象时，
         * 结果为 true。 
         */
        public boolean equals(Object obj) {
            if (obj instanceof Long) {
                return value == ((Long)obj).longValue();
            }
            return false;
        }
        /**
         * 返回系统常量的long值,类似System.getProperty(str);
         * @param nm	属性名
         * @return Long 
         */
        public static Long getLong(String nm) {
            return getLong(nm, null);
        }
        /**
         * 返回系统常量的long值,类似System.getProperty(str);
         * 如果为空，默认值为val
         * @param nm	属性名
         * @param val	默认值
         * @return Long 
         */
        public static Long getLong(String nm, long val) {
            Long result = Long.getLong(nm, null);
            return (result == null) ? Long.valueOf(val) : result;
        }
        /**
         * 返回具有指定名称的系统属性的long值。
         * @param nm	属性名
         * @param val	默认值
         * @return Long 
         */
        public static Long getLong(String nm, Long val) {
            String v = null;
            try {// 获取对应系统变量名的值
                v = System.getProperty(nm);
            } catch (IllegalArgumentException e) {
            } catch (NullPointerException e) {
            }
            if (v != null) {
                try {//返回字符串中的数字
                    return Long.decode(v);
                } catch (NumberFormatException e) {
                }
            }
            return val;
        }
        /**
         *比较两个 Long 对象的value值大小
         */
        public int compareTo(Long anotherLong) {
            return compare(this.value, anotherLong.value);
        }
    	/**
    	 * 比较两个long类型的值的大小
    	 * @param x
    	 * @param y
    	 * @return int 
    	 */
        public static int compare(long x, long y) {
            return (x < y) ? -1 : ((x == y) ? 0 : 1);
        }
        // 用来以二进制补码形式表示 long 值的位数
        public static final int SIZE = 64;
        /**
         * 返回在二进制情况下，i的最高位为1，其他全为0的值。
         * 将64位都置为1,然后将该值减去该值右移一位的值
         * @param i
         * @return long 
         */
        public static long highestOneBit(long i) {
            //右移一位或上原值
            i |= (i >>  1);
            i |= (i >>  2);
            i |= (i >>  4);
            i |= (i >>  8);
            i |= (i >> 16);
            i |= (i >> 32);
            //i值减去i右移一位的值
            return i - (i >>> 1);
        }
    	/**
    	 * 获取最低位为1，其他位都为0的值
    	 * @param i
    	 * @return long 
    	 */
        public static long lowestOneBit(long i) {
            // HD, Section 2-1
            return i & -i;
        }
        /**
         * 返回i的二进制从头开始有多少个0
         * @param i
         * @return int 
         */
        public static int numberOfLeadingZeros(long i) {
            //i为0，则有64个0
             if (i == 0)
                return 64;
            int n = 1;
            // 使用二分查找(也就是折半查找)思想，
            // 看右移16、24、28、30、31位的结果是否为0
            int x = (int)(i >>> 32);
            if (x == 0) { n += 32; x = (int)i; }
            if (x >>> 16 == 0) { n += 16; x <<= 16; }
            if (x >>> 24 == 0) { n +=  8; x <<=  8; }
            if (x >>> 28 == 0) { n +=  4; x <<=  4; }
            if (x >>> 30 == 0) { n +=  2; x <<=  2; }
            n -= x >>> 31;
            return n;
        }
        /**
         * 返回i的二进制从尾开始有多少个0
         * 基于二分查找
         * @param i
         * @return int 返回类型
         */
        public static int numberOfTrailingZeros(long i) {
            // HD, Figure 5-14
            int x, y;
            if (i == 0) return 64;
            int n = 63;
            y = (int)i; if (y != 0) { n = n -32; x = y; } else x = (int)(i>>>32);
            y = x <<16; if (y != 0) { n = n -16; x = y; }
            y = x << 8; if (y != 0) { n = n - 8; x = y; }
            y = x << 4; if (y != 0) { n = n - 4; x = y; }
            y = x << 2; if (y != 0) { n = n - 2; x = y; }
            return n - ((x << 1) >>> 31);
        }
        /**
         * 返回指定 long 值的二进制补码表示形式中的 1 位的数量。
         * 此功能有时被称为填充计算。 
         * @param i
         * @return int 
         */
         public static int bitCount(long i) {
            // 每两位一组统计看有多少个1
            // 0x55555555也就是01010101010101010101010101010101
            i = i - ((i >>> 1) & 0x5555555555555555L);
            // 每四位一组统计看有多少个1
            // 0x33333333也就是110011001100110011001100110011
            i = (i & 0x3333333333333333L) + ((i >>> 2) & 0x3333333333333333L);
            // 每八位的1的个数
            // 0x0f0f0f0f也就是00001111000011110000111100001111
            i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f0f0fL;
            // 每16位
            i = i + (i >>> 8);
            // 每32位
            i = i + (i >>> 16);
            // 每64位
            i = i + (i >>> 32);
            // 最终与0x7f进行与运算，得到的结果，就是1的个数
            return (int)i & 0x7f;
         }
        /**
         * 返回根据指定的位数循环左移指定的 long 值的二进制补码表示形式而得到的值。
         * （位是从左边（即高位）移出，从右边（即低位）再进入）
         * 注意，使用负距离的左循环等同于右循环：
         * rotateLeft(val, -distance) == rotateRight(val, distance)。
         * 还要注意的是，以 32 的任何倍数进行的循环都是无操作指令，
         * 因此，即使距离为负，除了最后五位外，
         * 其余所有循环距离都可以忽略：
         * rotateLeft(val, distance) == rotateLeft(val, distance & 0x1F)。 
         * @param i
         * @param distance
         * @return long 
         */
        public static long rotateLeft(long i, int distance) {
            return (i << distance) | (i >>> -distance);
        }
        /**
         * 返回根据指定的位数循环右移指定的 long 值的二进制补码表示形式而得到的值。
         * （位是从右边（即低位）移出，从左边（即高位）再进入） 
         * 注意，使用负距离的右循环等同于左循环：
         * rotateRight(val, -distance) == rotateLeft(val, distance)。
         * 还要注意的是，以 32 的任何倍数进行的循环都是无操作指令，
         * 因此，即使距离为负，除了最后五位外，
         * 其余所有循环距离都可以忽略：
         * rotateRight(val, distance) == rotateRight(val, distance & 0x1F)。 
         * @param i
         * @param distance
         * @return long 
         */
        public static long rotateRight(long i, int distance) {
            return (i >>> distance) | (i << -distance);
        }
        /**
         * 对i进行反转,反转也就是第1位和第64位对调，第2位和第63位对调等
         * @param i
         * @return int 
         */
        public static long reverse(long i) {
            // 将相邻两位进行对调
            i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L;
            // 将相邻四位进行对调
            i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L;
            // 将相邻的八位进行对调
            i = (i & 0x0f0f0f0f0f0f0f0fL) << 4 | (i >>> 4) & 0x0f0f0f0f0f0f0f0fL;
         // 将相邻的十六位进行对调
            i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
            // 64位中的中间32对调,最高十六位和最低十六位对调
            i = (i << 48) | ((i & 0xffff0000L) << 16) |
                ((i >>> 16) & 0xffff0000L) | (i >>> 48);
            return i;
        }
        /**
         * 返回指定 long 值的符号函数。（如果指定值为负，则返回 －1；
         * 如果指定值为零，则返回 0；如果指定的值为正，则返回 1。） 
         * @param i
         * @return int 
         */
        public static int signum(long i) {
            // HD, Section 2-7
            return (int) ((i >> 63) | (-i >>> 63));
        }
        /**
         * 返回通过反转指定 long 值的二进制补码表示形式中字节的顺序而获得的值
         * @param i
         * @return long 
         */
        public static long reverseBytes(long i) {
            i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
            return (i << 48) | ((i & 0xffff0000L) << 16) |
                ((i >>> 16) & 0xffff0000L) | (i >>> 48);
        }
        // 序列号
        private static final long serialVersionUID = 4290774380558885855L;
    }

参考：JDK 1.6 API