有关整数缓冲区的问题

问题：

同样为数字100为什么结果有时返回false，有时返回true，而用同样的方法再使用200，却带来不同的结果。具体看代码及运行结果。

匪夷所思的操作！！！（看代码及运行结果）

public class Main {
    public static void main(String[] args) {
        Integer n1=new Integer(100);
        Integer n2=new Integer(100);
        System.out.println(n1==n2);
        Integer n3=100;
        Integer n4=100;
        System.out.println(n3==n4);
        Integer n5=200;
        Integer n6=200;
        System.out.println(n5==n6);
    }
}

结果：

原因：

在解决问题前，先了解一下这两点：

• Java预先创建了256个常用的整数包装类型对象。（类似字符串中的字符串池，只是这个池中已经有内容了）
• 在实际应用当中，对已创建的对象进行复用。

为什么会出现这样的原因呢？？？

第一个可以理解，属于两个对象，两者所存储的地址不同，所以不相等返回false。但后面两个比较为神马如此令人匪夷所思！

通过自动装箱拆箱的实质（可以看这有关装箱拆箱），我们可以把上面的代码可以写成：

public class Main {
    public static void main(String[] args) {
        Integer n1=new Integer(100);
        Integer n2=new Integer(100);
        System.out.println(n1==n2);
        Integer n3=Integer.valueOf(100);//自动拆箱实质
        Integer n4=Integer.valueOf(100);
        System.out.println(n3==n4);
        Integer n5=Integer.valueOf(200);//自动拆箱实质
        Integer n6=Integer.valueOf(200);
        System.out.println(n5==n6);
    }
}

查看valueOf()源码如下：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}

发现：valueOf(int i)方法中的参数值在IntegerCache.low与IntegerCache.high之间时，会返回数组IntegerCache.cache[]中的值。

为查看三者的值查看IntegerCache类的源码如下：

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) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                }
            }
            high = h;
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
        private IntegerCache() {}
}

从源码中可以看出IntegerCache.low==-128、IntegerCache.high==127，同时可以看出数组cache[]大小为256，存放的元素为{-128,-127,…,126,127}。搞明白这一点后面的就迎刃而解。

回归问题，因为100在IntegerCache.low~IntegerCache.high之间，所以返回的是数组cache[]中的元素，所以在比较n3与n4时，两者指向的为同一元素，同一地址，而200并不在上面的范围中，所以返回new Interger(200) 。

相当于

public class Main{
    public static void main(String[] args) {
        Integer a[]={100};
        Integer n3=a[0];
        Integer n4=a[0];
        System.out.println(n3==n4);
        Integer n5=new Integer(200);
        Integer n6=new Integer(200);
        System.out.println(n5==n6);
    }
}

总结

1. 通过装箱拆箱的实质来将代码进行还原，再进行深度剖析源码。
2. 在学习这个知识点之前，开始的几行代码结果我一定认为全是true，但学完之后，发现Java的世界还有许多奇妙的事情等待探索。
3. 看懂源码真的很重要很重要，自己也要不断努力啊！！！

如有错误，欢迎指正。