int和Integer缓存的实现是怎样的

在Java中，int和Integer是两个非常基础且常用的数据类型。int是基本数据类型，而Integer是int的包装类。Java为了提高性能和减少内存消耗，对Integer类进行了缓存优化。本文将深入探讨int和Integer的区别，以及Integer缓存的实现机制。

1. int和Integer的区别

1.1 基本数据类型 vs 包装类

• int：int是Java中的基本数据类型之一，用于表示32位有符号整数。它直接存储在栈内存中，不涉及对象的创建和垃圾回收。

• Integer：Integer是int的包装类，属于Java的引用类型。它封装了一个int类型的字段，并提供了一系列方法用于操作整数。Integer对象存储在堆内存中，需要通过new关键字创建。

1.2 自动装箱与拆箱

Java 5引入了自动装箱（Autoboxing）和拆箱（Unboxing）机制，使得基本数据类型和其对应的包装类之间的转换更加方便。

• 自动装箱：将基本数据类型自动转换为对应的包装类对象。例如，int自动转换为Integer。

  Integer i = 10;  // 自动装箱

• 自动拆箱：将包装类对象自动转换为基本数据类型。例如，Integer自动转换为int。

  int j = i;  // 自动拆箱

2. Integer缓存的实现

为了提高性能和减少内存消耗，Java对Integer类进行了缓存优化。具体来说，Java在Integer类中维护了一个缓存池，用于缓存一定范围内的Integer对象。

2.1 缓存范围

Integer缓存的范围是-128到127。这个范围是Java规范中定义的，可以通过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) {
                // 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
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

从上面的代码可以看出，IntegerCache类在静态初始化块中创建了一个缓存数组cache，用于存储-128到127之间的Integer对象。

2.2 缓存的使用

当使用Integer.valueOf(int i)方法创建Integer对象时，如果i的值在-128到127之间，Java会直接从缓存中返回对应的Integer对象，而不是创建一个新的对象。

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

例如：

Integer a = Integer.valueOf(100);  // 从缓存中获取
Integer b = Integer.valueOf(100);  // 从缓存中获取
System.out.println(a == b);  // 输出 true

由于100在缓存范围内，a和b指向的是同一个缓存对象，因此a == b返回true。

2.3 超出缓存范围的情况

如果i的值超出了-128到127的范围，Integer.valueOf(int i)方法会创建一个新的Integer对象。

Integer c = Integer.valueOf(200);  // 创建新对象
Integer d = Integer.valueOf(200);  // 创建新对象
System.out.println(c == d);  // 输出 false

由于200超出了缓存范围，c和d分别指向不同的Integer对象，因此c == d返回false。

2.4 缓存范围的配置

Integer缓存的上限可以通过JVM参数-XX:AutoBoxCacheMax=<size>进行配置。例如，可以通过以下命令将缓存上限设置为1000：

java -XX:AutoBoxCacheMax=1000 MyClass

这样，Integer缓存的范围将变为-128到1000。

3. 缓存机制的影响

3.1 性能提升

通过缓存常用范围内的Integer对象，Java可以减少对象的创建和垃圾回收的开销，从而提高程序的性能。

3.2 内存节省

由于缓存范围内的Integer对象是共享的，因此可以减少内存的使用量，特别是在大量使用小整数的情况下。

3.3 注意事项

虽然缓存机制带来了性能提升和内存节省，但在某些情况下可能会导致意外的行为。例如：

Integer a = 100;
Integer b = 100;
System.out.println(a == b);  // 输出 true

Integer c = 200;
Integer d = 200;
System.out.println(c == d);  // 输出 false

由于100在缓存范围内，a和b指向同一个对象，因此a == b返回true。而200超出了缓存范围，c和d分别指向不同的对象，因此c == d返回false。

为了避免这种问题，建议在比较Integer对象时使用equals()方法，而不是==操作符。

System.out.println(c.equals(d));  // 输出 true

4. 总结

int和Integer在Java中有着不同的用途和特性。int是基本数据类型，而Integer是int的包装类。Java通过IntegerCache类实现了对-128到127范围内Integer对象的缓存，以提高性能和减少内存消耗。理解Integer缓存的实现机制，有助于编写更高效、更健壮的Java代码。