Integer--类中的对象池

public final class Integer extends Number implements Comparable<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);
    }
//看看上面的方法，如果i在范围内-128到127之间，则返回一个对象池中的引用。
    如果不在范围内，则new一个。   
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);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low));
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }


Java常量池

  IntegerTest {
       main(String[] args) {    
        objPoolTest();
    }

       objPoolTest() {
        Integer i1 = 40; // 默认调用Integer.valueOf(40)
        Integer i2 = 40;// 默认调用Integer.valueOf(40)
        Integer i3 = 0;// 默认调用Integer.valueOf(0)
        Integer i4 =  Integer(40);/ /直接new出一个对象来。
        Integer i5 =  Integer(40);/ /直接new出一个对象来。
        Integer i6 =  Integer(0); //直接new出一个对象来。
        
        System.out.println("i1=i2\t" + (i1 == i2));
        System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));
        System.out.println("i4=i5\t" + (i4 == i5));
        System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));    
        
        System.out.println();        
    }
}
i1=i2　　　　　　true
i1=i2+i3　　　  true
i4=i5　　　　　　false
i4=i5+i6　　　　true

Java为了提高性能提供了和String类一样的对象池机制，

当然Java的八种基本类型的包装类（Packaging Type）也有对象池机制。

Integer i1=40；Java在编译的时候会执行将代码封装成Integer i1=Integer.valueOf(40);

Integer.valueOf()中有个内部类IntegerCache（类似于一个常量数组，也叫对象池），它维护了一个Integer数组cache，长度为（128+127+1）=256；Integer类中还有一个Static Block(静态块)

 {
        ( i = 0; i < cache.length; i++)
        cache[i] =  Integer(i - 128);
 }


　　从这个静态块可以看出， Integer已经默认创建了数值【-128-127】的Integer缓存数据。所以使用Integer i1=40时，JVM会直接在该在对象池找到该值的引用。
 

　　这种方式声明一个Integer对象时，JVM首先会在Integer对象的缓存池中查找有木有值为40的对象，
如果有直接返回该对象的引用；
如果没有，则使用New keyword创建一个对象，并返回该对象的引用地址。
因为Java中【==】比较的是两个对象是否是同一个引用（即比较内存地址），

i2和i2都是引用的同一个对象，So i1==i2结果为”true“；

而使用new方式创建的i4=new Integer(40)、i5=new Integer(40)，虽然他们的值相等，
但是每次都会重新Create新的Integer对象，不会被放入到对象池中，所以他们不是同一个引用，输出false。



对于i1==i2+i3、i4==i5+i6结果为True，是因为，
Java的数学计算是在 内存栈里操作的，Java会对i5、i6进行拆箱操作， 其实比较的是基本类型（40=40+0），他们的值相同，因此结果为True。

　　
　　好了，我想说道这里大家应该都会对 Integer对象池有了更进一步的了解了吧，我在诺诺的问一句如果把40改为400猜猜会输出什么？

i1=i2　　　　false

i1=i2+i3　　true
i4=i5　　　　false
i4=i5+i6　　true


这是因为Integer i1=400，Integer i2=400他们的值 已经超出了常量池的范围，

JVM会对i1和i2各自创建新的对象（即Integer i1=new Integer(400)），所以他们不是同一个引用。