包装类的缓存问题

我不是女神ヾ 2023-10-03 13:11 3阅读 0赞

### 包装类的缓存问题 ###

整型、char类型所对应的包装类，在自动装箱时，对于-128~127之间的值会进行缓存处理，其目的是提高效率。

缓存处理的原理为：如果数据在-128~127这个区间，那么在类加载时就已经为该区间的每个数值创建了对象，并将这256个对象存放到一个名为cache的数组中。

每当自动装箱过程发生时(或者手动调用valueOf()时)，就会先判断数据是否在该区间，如果在则直接获取数组中对应的包装类对象的引用，如果不在该区间，则会通过new调用包装类的构造方法来创建对象。

比如以下这个测试程序：

Integer in1 = -128;
    Integer in2 = -128;
    System.out.println(in1 == in2);//true 因为123在缓存范围内
    System.out.println(in1.equals(in2));//true

出现这样的原因，可以查看Integer的源码：

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类的一个静态内部类，仅供Integer类使用，IntegerCache.low为-128，IntegerCache.high为127

缓存了\[-128,127\]之间的数字。实际就是系统初始的时候，创建了\[-128,127\]之间，的一个缓存数组。

当我们调用valueOf()的时候，首先检查是否在\[-128,127\]之间，如果在这个范围则直接从缓存数组中拿出已经创建好的对象

如果不在这个范围，则创建新的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 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() {
        }
        }

再来测试以下：

Integer in3 = 1234;
    Integer in4 = 1234;
    System.out.println(in3 == in4);//false 因为1234不在缓存范围内
    System.out.println(in3.equals(in4));//true

由于-128在\[128,127\]范围内，所以是从cache数组中直接取出创建好的对象，而1234超过了这个范围，那就直接new一个，导致了in3和in4是两个不同的对象。