Integer的相等比较

好比下面例子：

            Integer a1 = Integer.valueOf(60);  //直接比较
            Integer b1 = 60;    
            System.out.println("1:="+(a1 == b1));     
              
      
            Integer a2 = 60;    
            Integer b2 = 60;    
            System.out.println("2:="+(a2 == b2));    
              
      
            Integer a3 = new Integer(60);    //自动装箱
            Integer b3 = 60;    
            System.out.println("3:="+(a3 == b3));    
              
            Integer a4 = 129;    
            Integer b4 = 129;    
            System.out.println("4:="+(a4 == b4));   
            
            Integer a5 = new Integer(60);    //自动装箱
            Integer b5 = new Integer(60);    
            System.out.println("5:="+(a5 == b5)); 

你们能够猜一下输出是什么，也能够在ide里面运行一下，那么会发现，第四个为何输出false

1:=true
2:=true
3:=false
4:=false
5:=false

关于第五个，第三个输出应该没有什么异议，由于使用了new的，在==比较的时候只是针对对象引用地址做比较，因此为false，那么第2个为何和第四个输出不一样，这就涉及到jdk远吗里面，

jdk对-128 --127之间的数值设立了缓冲区，回去缓冲区读取数据，可是对于这个范围以外的数据没有缓冲区，因此第二个和第四个输出结果不同，下面是jdk对于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 HighPropValue =
                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) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            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() {}
    }

你们能够看到h值能够经过配置去指定，可是通常好像没人指定，因此此处的high通常就是127，low就是-128，cache是一个Integer类型的数组，在new的时候大小通常就是256，而后里面的值就是-128-127（j++就是先把前面的事情干了再去加一操做）

然而再看Integer.valueOf(60);这段在jdk中：

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

他会首先去检查缓冲区中的值，有的话就从缓冲区中取出，没有的话从新new一个，并且Integer i= 60；会被编译成Integer i = Integer.value(60);因此以第一个会输出true。

同理第四个在输出的时候129已经再也不缓冲区中了，就会从新再堆中new一个新对象，因此用等号去比较的时候只是比较的两个Integer对象的引用，因此会输出false。