Interger常量池，常量池上限调整

原理

Integer包装类有默认缓存池，范围是【 -128~127】 。
其他基本数据类型的包装类都有这个缓存池，包括：Byte,Short,Long。Float和Double没有

/*Integer的构造方法，接受一个整型参数,Integer对象表示的int值，保存在value中*/ 
public Integer(int value) {
    this.value = value;
}
/*equals()方法判断的是:所代表的int型的值是否相等*/ 
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        eturn value == ((Integer)obj).intValue();
    }
    return false;
}
/*返回这个Integer对象代表的int值，也就是保存在value中的值*/
public int intValue() {
    return value;
}
/** 
 * 首先会判断i是否在[IntegerCache.low,Integer.high]之间 
 * 如果是，直接返回Integer.cache中相应的元素 
 * 否则，调用构造方法，创建一个新的Integer对象 
 */
public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}
/** 
 * 静态内部类，缓存了从[low,high]对应的Integer对象 
 * low -128这个值不会被改变 
 * high 默认是127，可以改变，最大不超过：Integer.MAX_VALUE - (-low) -1 
 * cache 保存从[low,high]对象的Integer对象 
 */ 
private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];
    static {
            // high value may be configured by property        
            int h = 127;
            String integerCacheHighPropValue =            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // 最大的 数组 size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            }
            high = h;
            ache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
    }
    private IntegerCache() {}
}        

1. Integer有一个实例域value，它保存了这个Integer所代表的int型的值，且它是final的，也就是说这个Integer对象一经构造完成，它所代表的值就不能再被改变。
2. Integer重写了equals()方法，它通过比较两个Integer对象的value，来判断是否相等。
3. 重点是静态内部类IntegerCache，通过类名就可以发现：它是用来缓存数据的。它有一个数组，里面保存的是连续的Integer对象。
4. low：代表缓存数据中最小的值，固定是-128。
5. high：代表缓存数据中最大的值，它可以被该改变，默认是127。high最小是127，最大是Integer.MAXVALUE-(-low)-1，如果high超过了这个值，那么cache[ ]的长度就超过Integer.MAXVALUE了，也就溢出了。
6. cache[]：里面保存着从[low,high]所对应的Integer对象，长度是high-low+1(因为有元素0，所以要加1)。
7. 调用valueOf(int i)方法时，首先判断i是否在[low,high]之间，如果是，则复用Integer.cache[i-low]。比如，如果Integer.valueOf(3)，直接返回Integer.cache[131]；如果i不在这个范围，则调用构造方法，构造出一个新的Integer对象。
8. 调用intValue()，直接返回value的值。通过3和4可以发现，默认情况下，在使用自动装箱时，VM会复用[-128,127]之间的Integer对象。

java中整数常量池(-128~127)上限如何调整？

java中Integer有一个常量池范围-128~127

如果我想让　下面也返回true，该怎么做？
Integer a = 500, b = 500;
System.out.println(a == b);

答案就在java.lang.Integer.IntegerCache 这个类的源码上

/**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */

    private static class IntegerCache {
       // ...
    }

-XX:AutoBoxCacheMax=<size>
-Djava.lang.Integer.IntegerCache.high=<size>

这2个参数都可以控制上限。