JDK1.8源码阅读（十一）Java.lang.Long

Long

Long类的作用是对基础类型long进行封装，提供了一些处理long类型的方法。

定义

public final class Long extends Number implements Comparable<Long> {}

构造方法

属性

/*MIN_VALUE静态变量表示long能取的最小值，为-2的63次方，被final修饰说明不可变。*/
@Native public static final long MIN_VALUE = 0x8000000000000000L;

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

/*表示这是一个基础类型long的实例*/
@SuppressWarnings("unchecked")
    public static final Class<Long>     TYPE = (Class<Long>) Class.getPrimitiveClass("long");

/*使用long进行存储*/
private final long value;

/*表示补码二进制位数长度=64*/
@Native public static final int SIZE = 64;

/*补码二进制字节数*/
public static final int BYTES = SIZE / Byte.SIZE;

常用方法

 

/*转换成String格式，带进制信息的，它会转换成对应进制的字符串。凡是不在2到36进制范围之间的都会被处理成10进制，我们都知道从十进制转成其他进制时就是不断地除于进制数得到余数，然后把余数反过来串起来就是最后结果，所以这里其实也是这样子做的，得到余数后通过digits数组获取到对应的字符，而且这里是用负数的形式来运算的。*/
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));
    }
/*用stringSize得到数字是多少位，再用getChars获取数字对应的char数组，最后返回一个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];
        getChars(i, size, buf);
        return new String(buf, true);
    }

/*调用第二个toString*/
public String toString() {
        return toString(value);
    }

/*核心逻辑，因为LongCache缓存了[-128,127]值的Long对象，对于在范围内的直接从LongCache的数组中获取对应的Long对象即可，而在范围外的则需要重新实例化了。*/
public static Long valueOf(long l) {
        final int offset = 128;
        if (l >= -128 && l <= 127) { // will cache
            return LongCache.cache[(int)l + offset];
        }
        return new Long(l);
    }
public static Long valueOf(String s) throws NumberFormatException
    {
        return Long.valueOf(parseLong(s, 10));
    }
public static Long valueOf(String s, int radix) throws NumberFormatException {
        return Long.valueOf(parseLong(s, radix));
    }

/*主要作用是解码字符串转成Long型，比如Long.decode("11")的结果为11；Long.decode("0x11")和Long.decode("#11")结果都为17，因为0x和#开头的会被处理成十六进制；Long.decode("011")结果为9，因为0开头会被处理成8进制。*/
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;
    }

/*类型转换*/
public byte byteValue() {
  return (byte)value;
 }
public short shortValue() {
  return (short)value;
 }
public int intValue() {
  return (int)value;
 }
public long longValue() {
  return value;
 }
public float floatValue() {
  return (float)value;
 }
public double doubleValue() {
  return (double)value;
 }

......