首页 / 缓存 / java包装类的缓存机制（转）

java包装类的缓存机制（转）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java包装类的缓存机制（转），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含3801字，纯文字阅读大概需要6分钟。

内容图文

出处： java包装类的缓存机制

 

java 包装类的缓存机制，是在Java 5中引入的一个有助于节省内存、提高性能的功能，只有在自动装箱时有效

 

Integer包装类

举个栗子：

Integer a = 127;
Integer b = 127;
System.out.println(a == b);  // true

这段代码输出的结果为true

使用自动装箱将基本类型转为封装类对象这个过程其实底层实现是调用封装类的valueOf方法：

Integer a =127; 相当于 Integer a = Integer.valueOf(127);

看一下Integer的valueOf方法：

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

如果入参 i 大于等于IntegerCache.low或者小于等于IntegerCache.high)，就从IntegerCache中获取对象

看一下IntegerCache：

            private
            static
            class
             IntegerCache {
    
            static
            final
            int low = -128;
    staticfinalint high;
    staticfinal Integer cache[];

    static {
        // high value may be configured by propertyint 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之间，范围的最大值可以通过java.lang.Integer.IntegerCache.high设置，通过for循环将范围内的数据实例化为Integer对象放到cache数组里

在测试一下：

Integer a = 128;
Integer b = 128;
System.out.println(a == b); // false

输出结果为false，所以如果没有指定cache最大值时，在-128到127之间使用自动装箱时，会使用缓存

 

Byte包装类

再举个栗子：

            public
            static
            void
             main(String[] args) {
    Byte a = 127;
    Byte b = 127;
    System.out.println(a == b); //true
}

由于Byte范围在-128到127之间，所以Byte的valueOf都是从ByteCache缓存中获取的

            public
            static Byte valueOf(byte b) {
    finalint offset = 128;
    return ByteCache.cache[(int)b + offset];
}

ByteCache类：

            private
            static
            class
             ByteCache {
    
            private
             ByteCache(){}

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

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

与IntegerCache相比，ByteCache的最大值是不能修改的就是127

 

Short包装类 

            public
            static Short valueOf(short s) {
    finalint offset = 128;
    int sAsInt = s;
    if (sAsInt >= -128 && sAsInt <= 127) { // must cachereturn ShortCache.cache[sAsInt + offset];
    }
    returnnew Short(s);
}

ShortCache类：

            private
            static
            class
             ShortCache {
    
            private
             ShortCache(){}

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

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

ShortCache的最大值也不可以修改，范围只能在-128 ~ 127之间

Long包装类的valueOf方法和LongCache类与Short包装类的实现一致，范围也是只能在-128 ~ 127之间

 

Character包装类

valueOf方法：

            public
            static Character valueOf(char c) {
    if (c <= 127) { // must cachereturn CharacterCache.cache[(int)c];
    }
    returnnew Character(c);
}

CharacterCache类：

            private
            static
            class
             CharacterCache {
    
            private
             CharacterCache(){}

    
            static
            final Character cache[] = new Character[127 + 1];

    static {
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Character((char)i);
    }
}

Character的缓存范围在0 ~ 127之间

 

Boolean包装类

valueOf方法：

            public
            static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}

TRUE跟FALSE都是static final修饰的静态变量

            public
            static
            final Boolean TRUE = new Boolean(true);
publicstaticfinal Boolean FALSE = new Boolean(false);

 

Float包装类 & Double包装类

valueOf方法：

            public
            static Float valueOf(float f) {
    returnnew Float(f);
}
publicstatic Double valueOf(double d) {
    returnnew Double(d);
}

Float和Double没有使用缓存，直接new的对象

 

总结：

　　java的包装类中：Byte，Short，Integer，Long，Character使用static代码块进行初始化缓存，其中Integer的最大值可以通过java.lang.Integer.IntegerCache.high设置；Boolean使用static final实例化的对象；Float和Double直接new的对象没有使用缓存

 

原文：https://www.cnblogs.com/myseries/p/12076828.html

内容总结

以上是互联网集市为您收集整理的java包装类的缓存机制（转）全部内容，希望文章能够帮你解决java包装类的缓存机制（转）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1157120.html

来源：【匿名】