测试代码：

public class IntegerTest {
    public static void main(String[] args) {
        Integer i1 = 12;
        Integer i2 = 12;
        Integer i3 = 135;
        Integer i4 = 135;
        System.out.println("i1 == i2? " + (i1 == i2));
        System.out.println("i3 == i4? " + (i3 == i4));
    }
}

输出结果：

i1 == i2? true
i3 == i4? false

为什么都是Integer类的对象会输出不同的结果呢？
是因为Integer类的内部做了缓存处理，在Integer内部有一个IntegerCache的静态内部类，该内部类中会缓存-128到127的整数。当用一个int类型的变量给Integer时，会使用自动装箱的程序。

public final class Integer extends Number implements 
Comparable<Integer> {
  ...
  private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];
    ...
    cache = new Integer[(high-low)+1];
    int j = low;
    for(int k = 0;k < cache.length;k ++) 
      cache[k] = new Integer(j++);
      ...
  }
  ...
  //自动装箱的程序
  public static Integer valueOf(int i) {
    if(i >= IntegerCache.low && i <= IntegerCache.high)
      return IntegerCache.cache[i+(-IntegerCache.low)];
    return new Integer(i);
  }
  ...
}

为了进一步深入地理解Integer中的玄机，可以增加一下难度，使用synchronized关键字进一步验证。

public class ThreadA {
    static Integer integer = 8;
    public static void main(String[] args) throws InterruptedException{
        ThreadB b =new ThreadB();
        b.start();
        synchronized (integer) {
            System.out.println("deng dui xiang b wan cheng b wan 
cheng ....");
            integer.wait();
            System.out.println("b dui xiang zong he shi :" + b.total);
        }
    }
}
class ThreadB extends Thread {
    int total;
    Integer integer = 8;
    @Override
    public void run() {
        synchronized (integer) {
            for(int i = 0;i < 101;i ++) {
                total += i;
            }
            integer.notify();
            System.out.println("computing is finished");
        }
    }
}

输出结果

deng dui xiang b wan cheng b wan cheng ....
computing is finished
b dui xiang zong he shi :5050

程序中两处使用Integer类的对象作为监视器，两个Integer的对象都是分别new出来的，但是仍然可以实现两个线程的通信，所以从从此也可以判断出Integer内部是使用cache的机制。