---

前言

大家好，我是程序员梁白开。

你是否遇到过这样的 “玄学” 场景？同样是 Integer 对象比较，100100 返回 true，200200 却返回 false。如果你也曾被这种问题困扰，那说明你对 Java 包装类型的缓存机制还不够了解。这一隐藏在自动装箱背后的优化逻辑，既是提升性能的利器，也是开发中极易踩中的陷阱。今天我们就从原理、源码、实践三个维度，彻底搞懂包装类型的缓存机制。

---

一、直击痛点：为什么会有 “100100 为 true，200200 为 false”？

先看一段经典代码，感受下缓存机制带来的直观影响：

public class CacheDemo {
    public static void main(String[] args) {
        // 场景1：缓存范围内的自动装箱
        Integer a = 100;
        Integer b = 100;
        System.out.println(a == b); // 输出true
        System.out.println(a.equals(b)); // 输出true

        // 场景2：超出缓存范围的自动装箱
        Integer c = 200;
        Integer d = 200;
        System.out.println(c == d); // 输出false
        System.out.println(c.equals(d)); // 输出true

        // 场景3：缓存范围内但直接new对象
        Integer e = 100;
        Integer f = new Integer(100);
        System.out.println(e == f); // 输出false
        System.out.println(e.equals(f)); // 输出true
    }
}

同样是包装类对象比较，结果却大相径庭。这背后的核心原因，就是 Java 为提升性能引入的包装类型缓存机制 —— 对于高频使用的小范围数值，JVM 会提前创建对象并缓存，避免重复创建造成的内存浪费和性能损耗。

二、核心原理：哪些包装类有缓存？范围是多少？

并非所有包装类都实现了缓存机制，其缓存范围也各有不同。整理成表格一目了然：

包装类	缓存范围	可配置性	备注
Boolean	TRUE、FALSE 两个固定对象	不可配置	直接返回预定义实例
Byte	-128 ~ 127	不可配置	覆盖所有 Byte 取值范围
Short	-128 ~ 127	不可配置	常用小范围短整型
Integer	默认 - 128 ~ 127	可配置上限	唯一支持动态调整缓存的包装类
Long	-128 ~ 127	不可配置	与整型缓存范围保持一致
Character	0 ~ 127（ASCII 字符）	覆盖常用 ASCII 字符集
Float	无缓存机制	-	浮点数分布分散，缓存意义不大
Double	无缓存机制	-	浮点数分布分散，缓存意义不大

特别注意：Float 和 Double 没有实现缓存，因为浮点数的常用值分布零散，缓存带来的性能提升远不及维护成本。而 Boolean 由于只有两个可能值，直接采用预定义对象的方式，本质上也是一种特殊的缓存。

三、源码深挖：Integer 缓存是如何实现的？

以最具代表性的 Integer 为例，其缓存机制的实现堪称典范。核心逻辑封装在Integer类的静态内部类IntegerCache中，我们结合源码拆解其工作流程。

1. 缓存初始化逻辑

private static class IntegerCache {
    static final int low = -128;  // 缓存下限（固定不可改）
    static final int high;        // 缓存上限（可配置）
    static final Integer cache[]; // 缓存数组

    static {
        // 1. 初始化默认上限为127
        int h = 127;
        // 2. 读取JVM配置的缓存上限参数
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                // 确保配置值不小于127，避免无效配置
                i = Math.max(i, 127);
                // 确保数组不超出Integer的最大容量
                h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);
            } catch (NumberFormatException nfe) {
                // 配置解析失败则忽略
            }
        }
        high = h;

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

        // 4. 断言确保核心范围（-128~127）被缓存
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {} // 私有构造器禁止实例化
}

从源码可见，Integer 缓存的初始化发生在IntegerCache类加载时，通过静态代码块完成。这个过程是线程安全的，且缓存对象一旦创建就不会改变。

2. 缓存的获取逻辑

当我们使用自动装箱（如Integer a = 100）时，编译器会自动将其转换为Integer.valueOf()方法调用，这正是缓存机制的入口：

public static Integer valueOf(int i) {
    // 判断值是否在缓存范围内
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        // 从缓存数组中获取对象（计算数组下标：i - (-128) = i + 128）
        return IntegerCache.cache[i + (-IntegerCache.low)];
    // 超出范围则创建新对象
    return new Integer(i);
}

这就解释了开头的场景：100 在缓存范围内，直接返回缓存对象，所以a == b为 true；200 超出范围，每次都创建新对象，所以c == d为 false。

四、实战技巧：如何配置缓存？有哪些注意事项？

1. 调整 Integer 缓存上限

作为唯一可配置的包装类，Integer 支持通过 JVM 参数调整缓存上限：

-XX:AutoBoxCacheMax=<size>

例如将上限调整为 500：

java -XX:AutoBoxCacheMax=500 CacheDemo

此时再运行开头的代码，Integer c = 200; Integer d = 200;会返回 true，因为 200 已纳入缓存范围。

但不建议盲目扩大缓存范围：缓存对象会常驻内存，过大的缓存会占用大量方法区空间，甚至可能导致 OOM 异常。只有在明确知道应用会高频使用某一范围整数（如电商系统的商品 ID 前缀）时，才考虑调整。

2. 避坑指南：开发中必须遵守的 3 条规则

• 比较值用 equals，比较引用才用 ==
  包装类的本质是对象，==比较的是内存地址，equals才是比较值。《阿里巴巴 Java 开发手册》明确规定：“所有相同类型的包装类对象之间值的比较，全部使用 equals 方法比较”。
• 避免直接 new 包装类对象
  直接使用new Integer(100)会强制创建新对象，绕过缓存机制（如开头场景 3）。在 JDK9 之后，包装类的构造器已被标记为过时，推荐使用valueOf()或自动装箱。
• 集合操作注意自动拆装箱性能
  当向集合中添加基本类型时（如list.add(10)），会触发自动装箱。如果集合元素量大且值集中在缓存范围，缓存机制能显著提升性能；但如果频繁进行拆装箱（如循环中对集合元素做算术运算），仍会产生性能损耗，建议适时转换为基本类型处理。

五、面试高频：这些问题你必须会

1. 问：Integer、Long 的缓存范围是多少？可以修改吗？
   答：默认都是 - 128~127。其中 Integer 的上限可通过 JVM 参数 - XX:AutoBoxCacheMax 调整，下限固定为 - 128；Long 的缓存范围不可配置。
2. 问：为什么 Float 和 Double 没有缓存机制？
   答：因为浮点数的取值范围极广且分布分散，常用值没有明显的集中区间，缓存带来的性能提升无法覆盖维护成本，因此 Java 没有为其实现缓存。
3. 问：Integer a = 127; Integer b = new Integer(127); a == b的结果是什么？为什么？
   答：false。a 是通过自动装箱从缓存中获取的对象，b 是直接 new 的新对象，二者内存地址不同，所以 == 返回 false。

---

六、总结

包装类型的缓存机制是 Java 对性能优化的经典实践，通过复用高频对象减少内存开销。其核心逻辑可概括为：

• 类加载时初始化缓存数组，存储常用数值对应的包装对象
• 自动装箱时通过 valueOf () 方法获取缓存对象
• 超出范围则创建新对象

理解这一机制不仅能避免开发中的 "玄学"BUG，更能体现对 Java 底层原理的掌握。记住：缓存是优化手段而非银弹，合理使用、规范编码才是关键。