基础篇：Long源码解析

1.缓存

缓存问题是Long对象最受关注的问题，Long自身实现了一种缓存机制，缓存了从-128到127内所有的Long值，如果是这个范围内的Long值，就不会初始化，而是从缓存中拿取。

缓存初始化源码如下，

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);
    }
}

从-128到127存在256个值，构建一个长度为256的数组，数组中每个元素对应一个Long值。

2.valueOf与parseLong

使用Long时，推荐多使用valueOf方法而非parseLong的原因具体如下，

当创建Long对象传入构造方法的是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 Long(long value) {
    this.value = value;
}

当创建Long对象传入构造方法的是String类对象时，

// 当传入字符串作为参数时，内部实际上调用的就是parseLong
public static Long valueOf(String s, int radix) throws NumberFormatException {
    return Long.valueOf(parseLong(s, radix));
}

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) // 但是只传入正负号
                throw NumberFormatException.forInputString(s);
            i++;
        }
        multmin = limit / radix;
        while (i < len) {
            // 负累积避免了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;
}
    
public static long parseLong(String s) throws NumberFormatException {
    return parseLong(s, 10);
}

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

• 只有在构造时传入long类型数据作为参数时，才会触发缓存机制。如果long在-128到127这个范围内，从缓存中取出会减少资源的开销。如果是使用parseLong方法，则没有这种机制。

• 当传入构造方法的是String类型时，valueOf和parseLong是等价的。