Integer的缓存机制

前提：

在印象中 ==与 equals 的区别在于 == 比较的是对象的地址而equals比较的是内容.

而事实却是equals默认比较的也是对象的引用，但很多类中对其重写了导致它可以比较引用。

例如String:

public boolean equals(Object anObject) {
  if (this == anObject) {
    return true;
  }
  if (anObject instanceof String) {
    String anotherString = (String)anObject;
    int n = value.length;
    if (n == anotherString.value.length) {
      char v1[] = value;
      char v2[] = anotherString.value;
      int i = 0;
      while (n-- != 0) {
        if (v1[i] != v2[i])
          return false;
        i++;
      }
      return true;
    }
  }
  return false;
}

接下来重点来了,来道题目：

    public static void main(String[] args) {
        Integer l1 = 120;
        Integer l2 = 120;
        Integer l3 = new Integer(120);
        System.out.println(l1 == l2);
        System.out.println(l1 == l3);
    }

结果为：

   true

   false

为什么呢？字面量的形式去定义Integer会默认调用Integer类中的valueOf方法

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

重要的IntegerCache，为了优化，默认会把一些常用的小的数字缓存起来，这样使用的时候不需要每次都去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) {
      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() {}
}

从以上代码中可以看到默认会把 -128 到 127的值缓存起来。

好了知道原理了再次尝试

public static void main(String[] args) {
  Integer l1 = 120;
  Integer l2 = 120;
  Integer l3 = 128;
  Integer l4 = 128;
  System.out.println(l1 == l2); //true
  System.out.println(l3 == l4); //false

}

华丽结束。

想一起交流的朋友可以关注我的公众号，每天会同步更新
博客连接 ： AshinLee’s blog