Java学习(22) -- 源码阅读（Long）

/**
 * auther: jiyx
 * date: 2018/9/18.
 */
public class Long extends Number implements Comparable {
    /**
     * 最小值，-2的63次方
     */
    @Native
    public static final long MIN_VALUE = 0x8000000000000000L;

    /**
     * 最大值，2的63次方减1
     */
    @Native
    public static final long MAX_VALUE = 0x7fffffffffffffffL;

    /**
     * 返回long的class类型
     */
    @SuppressWarnings("unchecked")
    public static final Class<Long> TYPE = (Class<Long>) Class.getPrimitiveClass("long");

    /**
     * 以指定基数返回指定数的表示形式,传入的可以使十六进制，8进制，10进制
     * 返回的可以使3进制、5进制最小2进制，最大36进制
     */
    public static String toString(long i, int radix) {
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;
        if (radix == 10)
            return toString(i);
        char[] buf = new char[65];
        int charPos = 64;
        boolean negative = (i < 0);

        // 非负数，转为负数
        if (!negative) {
            i = -i;
        }

        while (i <= -radix) {
            buf[charPos--] = Integer.digits[(int) (-(i % radix))];
            i = i / radix;
        }
        buf[charPos] = Integer.digits[(int) (-i)];

        if (negative) {
            buf[--charPos] = '-';
        }

        return new String(buf, charPos, (65 - charPos));
    }

    /**
     * 根据基数返回无符号的二进制形式，这里将正数和负数分开处理
     * 是因为负数的二进制其实就是正数的反码加一，所以要不同处理
     */
    public static String toUnsignedString(long i, int radix) {
        if (i >= 0)
            // 大于0的直接toString，而Integer的toUnsignedString，就是先转换成了无符号的int，也会走这里
            return toString(i, radix);
        else {
            // 小于0的要根据不同情况进行处理
            switch (radix) {
                case 2:
                    return toBinaryString(i);

                case 4:
                    return toUnsignedString0(i, 2);

                case 8:
                    return toOctalString(i);

                case 10:
                    /*
                     * We can get the effect of an unsigned division by 10
                     * on a long value by first shifting right, yielding a
                     * positive value, and then dividing by 5.  This
                     * allows the last digit and preceding digits to be
                     * isolated more quickly than by an initial conversion
                     * to BigInteger.
                     */
                    long quot = (i >>> 1) / 5;
                    long rem = i - quot * 10;
                    return toString(quot) + rem;

                case 16:
                    return toHexString(i);

                case 32:
                    return toUnsignedString0(i, 5);

                default:
                    return toUnsignedBigInteger(i).toString(radix);
            }
        }
    }

    /**
     * 返回指定值的BitInteger的无符号表示形式
     * .
     */
    private static BigInteger toUnsignedBigInteger(long i) {
        if (i >= 0L)
            return BigInteger.valueOf(i);
        else {
            int upper = (int) (i >>> 32);
            int lower = (int) i;

            // return (upper << 32) + lower
            return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
                    add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
        }
    }

    /**
     * 返回16进制表示形式，入参可以使8，16，10进制
     */
    public static String toHexString(long i) {
        return toUnsignedString0(i, 4);
    }

    /**
     * 返回八进制表示形式，入参可以使8，16，10进制
     */
    public static String toOctalString(long i) {
        return toUnsignedString0(i, 3);
    }

    /**
     * 返回二进制表示形式，入参可以使8，16，10进制
     */
    public static String toBinaryString(long i) {
        return toUnsignedString0(i, 1);
    }

    /**
     * 将long(这里会将long当做无符号的long处理)转成字符串
     */
    static String toUnsignedString0(long val, int shift) {
        // assert shift > 0 && shift <=5 : "Illegal shift value";
        // 计算val实际占用的bit
        int mag = Long.SIZE - Long.numberOfLeadingZeros(val);
        // 计算需要打印的字符串的长度
        int chars = Math.max(((mag + (shift - 1)) / shift), 1);
        char[] buf = new char[chars];

        // 填充buf
        formatUnsignedLong(val, shift, buf, 0, chars);
        return new String(buf, true);
    }

    /**
     * 将指定数的字符串表示形式填充到char数组
     */
    static int formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {
        int charPos = len;
        int radix = 1 << shift;
        int mask = radix - 1;
        do {
            // 由后向前填充
            buf[offset + --charPos] = Integer.digits[((int) val) & mask];
            val >>>= shift;
        } while (val != 0 && charPos > 0);

        return charPos;
    }

    /**
     * 返回指定数的十进制字符串
     * 
     */
    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数组
        getChars(i, size, buf);
        return new String(buf, true);
    }

    /**
     * 返回指定数的十进制的无符号的字符串形式
     */
    public static String toUnsignedString(long i) {
        return toUnsignedString(i, 10);
    }

    /**
     * 这里只用于十进制的数填充到char[]数组中
     */
    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;
        }

        // 大于Integer的最大值时
        // 这里主是需要进行一个强转
        while (i > Integer.MAX_VALUE) {
            q = i / 100;
            // really: r = i - (q * 100);
            r = (int) (i - ((q << 6) + (q << 5) + (q << 2)));
            i = q;
            buf[--charPos] = Integer.DigitOnes[r];
            buf[--charPos] = Integer.DigitTens[r];
        }

        // 这下面就和Integer的处理一样了
        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));
            i2 = q2;
            buf[--charPos] = Integer.DigitOnes[r];
            buf[--charPos] = Integer.DigitTens[r];
        }

        for (; ; ) {
            q2 = (i2 * 52429) >>> (16 + 3);
            r = i2 - ((q2 << 3) + (q2 << 1));  // r = i2-(q2*10) ...
            buf[--charPos] = Integer.digits[r];
            i2 = q2;
            if (i2 == 0) break;
        }
        if (sign != 0) {
            buf[--charPos] = sign;
        }
    }

    /**
     * 计算正整数的位数
     * @param x
     * @return
     */
    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;
    }

    /**
     * 根据基数，返回字符串代表的数字的十进制形式
     * <p>示例:
     * <blockquote><pre>
     * parseLong("0", 10) returns 0L
     * parseLong("473", 10) returns 473L
     * parseLong("+42", 10) returns 42L
     * parseLong("-0", 10) returns 0L
     * parseLong("-FF", 16) returns -255L
     * parseLong("1100110", 2) returns 102L
     * parseLong("99", 8) throws a NumberFormatException
     * parseLong("Hazelnut", 10) throws a NumberFormatException
     * parseLong("Hazelnut", 36) returns 1356099454469L
     *
     */
    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') {
                if (firstChar == '-') {
                    negative = true;
                    limit = Long.MIN_VALUE;
                } else if (firstChar != '+')
                    throw NumberFormatException.forInputString(s);

                // 字符串不能只有+和-号
                if (len == 1) // Cannot have lone "+" or "-"
                    throw NumberFormatException.forInputString(s);
                i++;
            }
            multmin = limit / radix;
            while (i < len) {
                // Accumulating negatively avoids surprises near MAX_VALUE
                digit = Character.digit(s.charAt(i++), radix);
                if (digit < 0) {
                    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
     */
    public static long parseLong(String s) throws NumberFormatException {
        return parseLong(s, 10);
    }

    /**
     * 与toUnsignedString对应，根据基数将无符号的字符串表示的数还原为十进制
     */
    public static long parseUnsignedLong(String s, int radix)
            throws NumberFormatException {
        if (s == null) {
            throw new NumberFormatException("null");
        }

        int len = s.length();
        if (len > 0) {
            char firstChar = s.charAt(0);
            // 无符号字符串不能有负号
            if (firstChar == '-') {
                throw new
                        NumberFormatException(String.format("Illegal leading minus sign " +
                        "on unsigned string %s.", s));
            } else {
                // Long.MAX_VALUE在基数为36时，str的长度是13
                // 在基数为10时，str的长度为19
                if (len <= 12 ||
                        (radix == 10 && len <= 18)) {
                    return parseLong(s, radix);
                }

                // No need for range checks on len due to testing above.
                long first = parseLong(s.substring(0, len - 1), radix);
                int second = Character.digit(s.charAt(len - 1), radix);
                if (second < 0) {
                    throw new NumberFormatException("Bad digit at end of " + s);
                }
                long result = first * radix + second;
                // 这里就是溢出了long能表示的最大无符号数
                if (compareUnsigned(result, first) < 0) {
                    /*
                     * 最大无符号值（2 ^ 64）-1最多需要一个数字来表示最大有符号值（2 ^ 63）-1。
                     * 因此，解析（len-1）数字将适当地在签名解析的范围内。
                     * 所以，如果解析（len -1）数字溢出了签名解析，解析len数字肯定会溢出无符号解析。
                     * 上面的compareUnsigned检查捕获了包含最终数字贡献的无符号溢出的情况。
                     */
                    throw new NumberFormatException(String.format("String value %s exceeds " +
                            "range of unsigned long.", s));
                }
                return result;
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
    }

    /**
     * 与toUnsignedString对应，根据基数10将无符号的字符串表示的数还原为十进制
     */
    public static long parseUnsignedLong(String s) throws NumberFormatException {
        return parseUnsignedLong(s, 10);
    }

    /**
     * 根据指定基数，返回字符串的十进制的Long对象
     */
    public static Long valueOf(String s, int radix) throws NumberFormatException {
        return Long.valueOf(parseLong(s, radix));
    }

    /**
     * 基数为10，返回字符串的十进制的Long对象
     */
    public static Long valueOf(String s) throws NumberFormatException {
        return Long.valueOf(parseLong(s, 10));
    }

    /**
     * Long的缓存，缓存-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);
        }
    }

    /**
     * 自动装箱
     */
    public static Long valueOf(long l) {
        final int offset = 128;
        if (l >= -128 && l <= 127) { // will cache
            return Long.LongCache.cache[(int) l + offset];
        }
        return new Long(l);
    }

    /**
     * 解码字符串，返回一个Long
     * 可带-、+号
     * 可接受十进制、16进制、8进制
     * #、0x和0X开头代表16进制
     * 0开头代表8进制
     * <p>
     * <blockquote>
     * <dl>
     * <dt><i>DecodableString:</i>
     * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i>
     * <dd><i>Sign<sub>opt</sub></i> {@code 0x} <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
     */
    public static Long decode(String nm) throws NumberFormatException {
        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);
        // Handle sign, if present
        if (firstChar == '-') {
            negative = true;
            index++;
        } else if (firstChar == '+')
            index++;

        // Handle radix specifier, if present
        if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
            index += 2;
            radix = 16;
        } else if (nm.startsWith("#", index)) {
            index++;
            radix = 16;
        } 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);
            result = negative ? Long.valueOf(-result.longValue()) : result;
        } catch (NumberFormatException e) {
            // If number is Long.MIN_VALUE, we'll end up here. The next line
            // handles this case, and causes any genuine format error to be
            // rethrown.
            String constant = negative ? ("-" + nm.substring(index))
                    : nm.substring(index);
            result = Long.valueOf(constant, radix);
        }
        return result;
    }

    /**
     * 实际存储的long
     *
     * @serial
     */
    private final long value;

    /**
     * 实例化
     */
    public Long(long value) {
        this.value = value;
    }

    /**
     * 根据字符串实例化，这个字符串会以十进制解析
     */
    public Long(String s) throws NumberFormatException {
        this.value = parseLong(s, 10);
    }

    /**
     * 缩窄到byte，如果value超出了byte的范围，那么会返回截取后的数，不会报错的
     */
    public byte byteValue() {
        return (byte) value;
    }

    /**
     * 缩窄到short，如果value超出了short的范围，那么会返回截取后的数，不会报错的
     */
    public short shortValue() {
        return (short) value;
    }

    /**
     * 缩窄到int，如果value超出了int的范围，那么会返回截取后的数，不会报错的
     */
    public int intValue() {
        return (int) value;
    }

    /**
     * 返回long
     */
    public long longValue() {
        return value;
    }

    /**
     * 向上转型
     */
    public float floatValue() {
        return (float) value;
    }

    /**
     * 向上转型
     */
    public double doubleValue() {
        return (double) value;
    }

    /**
     * toString
     */
    public String toString() {
        return toString(value);
    }

    /**
     * hashCode
     */
    @Override
    public int hashCode() {
        return Long.hashCode(value);
    }

    /**
     * hashCode，静态
     */
    public static int hashCode(long value) {
        return (int) (value ^ (value >>> 32));
    }

    /**
     * equals
     */
    public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long) obj).longValue();
        }
        return false;
    }

    /**
     * 根据系统属性名返回对应的Long对象
     */
    public static Long getLong(String nm) {
        return getLong(nm, null);
    }

    /**
     * 根据系统属性名返回对应的Long对象，可以给默认值
     */
    public static Long getLong(String nm, long val) {
        Long result = Long.getLong(nm, null);
        return (result == null) ? Long.valueOf(val) : result;
    }

    /**
     * 根据系统属性名返回对应的Long对象，可以给默认值
     */
    public static Long getLong(String nm, Long val) {
        String v = null;
        try {
            v = System.getProperty(nm);
        } catch (IllegalArgumentException | NullPointerException e) {
        }
        if (v != null) {
            try {
                return Long.decode(v);
            } catch (NumberFormatException e) {
            }
        }
        return val;
    }

    /**
     * compareTo
     */
    public int compareTo(Long anotherLong) {
        return compare(this.value, anotherLong.value);
    }

    /**
     * 比较两个数
     */
    public static int compare(long x, long y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

    /**
     * 比较两个数，以无符号方式
     */
    public static int compareUnsigned(long x, long y) {
        return compare(x + MIN_VALUE, y + MIN_VALUE);
    }


    /**
     * 用第一个参数除以第二个参数求商，以无符号的方式，并且返回的结果也是个无符号数
     */
    public static long divideUnsigned(long dividend, long divisor) {
        if (divisor < 0L) { // signed comparison
            // Answer must be 0 or 1 depending on relative magnitude
            // of dividend and divisor.
            return (compareUnsigned(dividend, divisor)) < 0 ? 0L : 1L;
        }

        if (dividend > 0) //  Both inputs non-negative
            return dividend / divisor;
        else {
            /*
             * For simple code, leveraging BigInteger.  Longer and faster
             * code written directly in terms of operations on longs is
             * possible; see "Hacker's Delight" for divide and remainder
             * algorithms.
             */
            return toUnsignedBigInteger(dividend).
                    divide(toUnsignedBigInteger(divisor)).longValue();
        }
    }

    /**
     * 用第一个参数除以第二个参数求余数，以无符号的方式，并且返回的结果也是个无符号数
     */
    public static long remainderUnsigned(long dividend, long divisor) {
        if (dividend > 0 && divisor > 0) { // signed comparisons
            return dividend % divisor;
        } else {
            if (compareUnsigned(dividend, divisor) < 0) // Avoid explicit check for 0 divisor
                return dividend;
            else
                return toUnsignedBigInteger(dividend).
                        remainder(toUnsignedBigInteger(divisor)).longValue();
        }
    }

    // Bit Twiddling

    /**
     * long占的bit位数
     */
    @Native
    public static final int SIZE = 64;

    /**
     * long站的byte位数
     */
    public static final int BYTES = SIZE / Byte.SIZE;

    /**
     * 二进制最高位1的权值，
     * 如5的二进制101，最低位的1在最低位，权值为4
     * 10的二进制1010，最低位的1在倒数第二位，权值为8
     */
    public static long highestOneBit(long i) {
        // HD, Figure 3-1
        i |= (i >> 1);
        i |= (i >> 2);
        i |= (i >> 4);
        i |= (i >> 8);
        i |= (i >> 16);
        i |= (i >> 32);
        return i - (i >>> 1);
    }

    /**
     * 二进制最低位1的权值，
     * 如5的二进制101，最低位的1在最低位，权值为1
     * 10的二进制1010，最低位的1在倒数第二位，权值为2
     */
    public static long lowestOneBit(long i) {
        // HD, Section 2-1
        return i & -i;
    }

    /**
     * 计算出指定值的二进制上高位的零的个数
     * 可能这个表达不是很合适，这里的高位就是从前向后数0的个数
     */
    public static int numberOfLeadingZeros(long i) {
        // HD, Figure 5-6
        if (i == 0)
            return 64;
        int n = 1;
        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;
    }

    /**
     * 指定数的二进制的低位上的0的个数。
     * 可能这个表达不是很合适，这里的低位就是从后向前数0的个数
     */
    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);
    }

    /**
     * 计算指定数的二进制中1的个数
     */
    public static int bitCount(long i) {
        // HD, Figure 5-14
        i = i - ((i >>> 1) & 0x5555555555555555L);
        i = (i & 0x3333333333333333L) + ((i >>> 2) & 0x3333333333333333L);
        i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f0f0fL;
        i = i + (i >>> 8);
        i = i + (i >>> 16);
        i = i + (i >>> 32);
        return (int) i & 0x7f;
    }

    /**
     * 循环左移，也就是将i向左移动distance位，
     * 当i的移位到达了最高位还没有够distance，那么移位的数就去低位开头，继续移位。
     * 所以叫做循环移位。distance可以为负
     */
    public static long rotateLeft(long i, int distance) {
        return (i << distance) | (i >>> -distance);
    }

    /**
     * 循环右移，也就是将i向右移动distance位，
     * 当i的移位到达了最低位还没有够distance，那么移位的数就去高位开头，继续移位。
     * 所以叫做循环移位。distance可以为负
     */
    public static long rotateRight(long i, int distance) {
        return (i >>> distance) | (i << -distance);
    }

    /**
     * 二进制翻转指定值，返回翻转之后的值
     */
    public static long reverse(long i) {
        // HD, Figure 7-1
        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;
        i = (i << 48) | ((i & 0xffff0000L) << 16) |
                ((i >>> 16) & 0xffff0000L) | (i >>> 48);
        return i;
    }

    /**
     * 判断传入的值是正数、负数或者零
     * -1，负数
     * 1，正数
     * 0，零
     */
    public static int signum(long i) {
        // HD, Section 2-7
        return (int) ((i >> 63) | (-i >>> 63));
    }

    /**
     * 按照一个Byte位，也就是8位翻转
     */
    public static long reverseBytes(long i) {
        i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
        return (i << 48) | ((i & 0xffff0000L) << 16) |
                ((i >>> 16) & 0xffff0000L) | (i >>> 48);
    }

    /**
     * 求和
     */
    public static long sum(long a, long b) {
        return a + b;
    }

    /**
     * 取大值
     */
    public static long max(long a, long b) {
        return Math.max(a, b);
    }

    /**
     * 取小值
     */
    public static long min(long a, long b) {
        return Math.min(a, b);
    }

    /**
     * use serialVersionUID from JDK 1.0.2 for interoperability
     */
    @Native
    private static final long serialVersionUID = 4290774380558885855L;
}

转自：https://www.jianshu.com/p/5747d003a082