具有缓存功能的类(Integer、Long等)

最新推荐文章于 2024-05-02 19:07:19 发布

Adonis_D_Gogh

最新推荐文章于 2024-05-02 19:07:19 发布

阅读量304

点赞数 1

分类专栏： JAVA

JAVA 专栏收录该内容

93 篇文章 0 订阅

订阅专栏

本文深入探讨Java中Integer类的缓存机制，解释如何在-128至127范围内复用Integer实例，以及Byte、Short、Long、Character等类的类似机制。通过具体代码示例，阐述缓存机制的工作原理及其对对象比较的影响。

摘要由CSDN通过智能技术生成

转自 https://www.cnblogs.com/rouqinglangzi/p/8848607.html

一、Integer类的缓存机制

我们查看Integer的源码，就会发现里面有个静态内部类。

 public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        //当前值在缓存数组区间段，则直接返回该缓存值
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        //否则创建新的Integer实例
        return new Integer(i);
    }
    
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        //IntegerCache初始化时，缓存数值为-128-127的Integer实例(默认是从-128到127)。
        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) {
                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);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            //填充缓存数组
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

该类的作用是将数值等于-128-127(默认)区间的Integer实例缓存到cache数组中。通过valueOf()方法很明显发现，当再次创建值在-128-127区间的Integer实例时，会复用缓存中的实例，也就是直接指向缓存中的Integer实例。

(注意：这里的创建不包括用new创建，new创建对象不会复用缓存实例，通过情景3的运行结果就可以得知)

二、其它具有缓存机制的类

实际上不仅仅Integer具有缓存机制，Byte、Short、Long、Character都具有缓存机制。

来看看Long类中的缓存类

    private static class LongCache {
        private LongCache(){}

        static final Long cache[] = new Long[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Long(i - 128);
        }
    }

ByteCache用于缓存Byte对象，ShortCache用于缓存Short对象，LongCache用于缓存Long对象，CharacterCache用于缓存Character对象。

这些类都有缓存的范围，其中Byte，Short，Integer，Long为 -128 到 127，Character范围为 0 到 127。

除了 Integer 可以通过参数改变范围外，其它的都不行。

三、面试题

有了上面的知识，很容易就能知道下面程序的输出了。

//情景1
Integer a = 1;
Integer b = 1;
System.out.println(a == b);//true

//情景2
Integer c = 128;
Integer d = 128;
System.out.println(c == d);//false

//情景3
Integer e = new Integer(1);
Integer f = new Integer(1);
System.out.println(e == f);//false

总结

1.具有缓存机制的类？

Byte、Short、Integer、Long、Character都具有缓存机制。缓存工作都是在静态块中完成，在类生命周期（loading verify prepare resolving initial using unload）的初始化阶段执行。

2.缓存范围？

Byte，Short，Integer，Long为 -128 到 127，Character范围为 0 到 127

3.是否可以改变缓存范围？

除了Integer可以指定缓存范围，其它类都不行。

Integer的缓存上界high可以通过jvm参数-XX:AutoBoxCacheMax=size指定，取指定值与127的最大值并且不超过Integer表示范围，而下界low不能指定，只能为-128。