1、缓存范围

默认情况下，Integer缓存预先创建并存储了值在 -128 到 127 之间的整数对象。这个范围是固定的，因为它被定义为标准Java规范的一部分。-128 到 127 范围内的整数使用非常频繁，重用这些对象可以显著节省内存。

public class Main {
  public static void main(String[] args) {
	  Integer integer1 = 3;
		Integer integer2 = 3;
		if (integer1 == integer2)
			System.out.println("integer1 == integer2");
		else
			System.out.println("integer1 != integer2");
		Integer integer3 = 300;
		Integer integer4 = 300;
		if (integer3 == integer4)
			System.out.println("integer3 == integer4");
		else
			System.out.println("integer3 != integer4");

  }
}

2、自动装箱

Integer 类是 int 类型的包装类，它提供了一系列方法来操作 int 数据，并且是集合框架（如 ArrayList 和 HashMap）中使用的类。Java 为了优化性能和内存使用，在 Integer 类中实现了一个缓存机制，这个机制与自动装箱（Autoboxing）紧密相关。当一个基本类型的int值在这个范围内时，通过自动装箱转换为Integer对象，Java会直接从缓存中返回已存在的对象，而不是创建一个新的Integer实例。

public class Main {
  public static void main(String[] args) {
    Integer a = 100; // 自动装箱，使用缓存
    Integer b = 100; // 自动装箱，使用缓存
    System.out.println(a == b); // true，因为 a 和 b 指向相同的缓存对象
    
    Integer c = 200; // 自动装箱，不在缓存范围，创建新对象
    Integer d = 200; // 自动装箱，不在缓存范围，创建新对象
    System.out.println(c == d); // false，因为 c 和 d 指向不同的对象

  }
}

3、配置缓存大小

虽然标准的缓存大小是固定的，但是可以通过JVM启动参数 -XX:AutoBoxCacheMax=size 来设置缓存的上限。可以缓存更大范围内的整数值，但应谨慎使用，因为这会增加JVM启动时的内存占用。

4、Java Integer包装类缓存的实现

Java 5 中引入了 Integer 包装类的缓存机制，旨在节省内存和提升性能。该机制对 -128 到 127 之间的 Integer 对象进行缓存，当需要使用在这个范围中某个值 的 Integer 对象时，会直接从缓存中返回，而不是每次都创建新的对象。Integer 类有一个名为 IntegerCache 的内部静态类，该类包含一个缓存数组，其中存储了 -128 到 127 之间的 Integer 对象。

Java JDK 1.8.0 build25的valueOf(int i)源码如下，

/**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache是在Integer类中私有的(private)静态内部类，代码如下，

 /**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */
    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() {}
    }

5、其它包装类对象缓存

包装类缓存是不仅仅应用在Integer包装类对象，ByteCache缓存Byte对象，ShortCache缓存Short对象，LongCache缓存Long对象，CharacterCache缓存Character对象。

public class Main {
  public static void main(String[] args) {
        Byte b1 = 127;
        Byte b2 = 127;
        System.out.println(b1 == b2); // true

        Byte b3 = new Byte((byte) 127);
        System.out.println(b1 == b3); // false
        
        
        Short s1 = 127;
        Short s2 = 127;
        System.out.println(s1 == s2); // true

        Short s3 = new Short((short) 127);
        System.out.println(s1 == s3); // false
        
        
        Long l1 = 127L;
        Long l2 = 127L;
        System.out.println(l1 == l2); // true

        Long l3 = new Long(127L);
        System.out.println(l1 == l3); // false
        
        
        Character c1 = 'a';
        Character c2 = 'a';
        System.out.println(c1 == c2); // true

        Character c3 = new Character('a');
        System.out.println(c1 == c3); // false

  }
}