缓存池机制（Cache Pool）

核心概念

Java为了提升性能和节省内存，在包装类中实现了对象复用机制：对于常用的数值范围，JVM会提前创建对象并缓存，多次使用时返回同一个对象，而不是重复创建。

---

一、为什么需要缓存池？

1.1 问题背景

// 假设没有缓存池
Integer a = 10;  // 创建对象1
Integer b = 10;  // 创建对象2
Integer c = 10;  // 创建对象3
// 小数值频繁使用，会创建大量重复对象，浪费内存

1.2 设计动机

根据实践统计，大部分数值操作集中在 -128 ~ 127 范围内：

• 循环计数器：for (int i = 0; i < 100; i++)
• 状态码：HTTP状态码200、404等
• 业务标识：1表示成功、0表示失败

缓存池策略：提前创建这些常用对象，减少内存分配和GC压力。

---

二、Integer缓存池实现

2.1 源码分析（JDK 8）

public static Integer valueOf(int i) {
    // 判断是否在缓存范围内
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];  // 返回缓存对象
    return new Integer(i);  // 超出范围，创建新对象
}

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

    static {
        // 默认上限127，可通过JVM参数调整
        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);  // 最小不低于127
                h = Math.min(i, Integer.MAX_VALUE - 129);  // 最大上限
            } catch( NumberFormatException nfe) { }
        }
        high = h;

        // 预先创建缓存对象
        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);  // 填充-128到high的所有Integer对象
    }
}

2.2 工作流程

调用Integer.valueOf(100)
        ↓
判断: 100 >= -128 && 100 <= 127
        ↓ true
返回: IntegerCache.cache[100 - (-128)]  // 下标228
        ↓
返回缓存的同一个对象

2.3 典型案例

// 案例1：缓存范围内
Integer a = 127;
Integer b = 127;
System.out.println(a == b);  // true（同一对象）

// 案例2：缓存范围外
Integer x = 128;
Integer y = 128;
System.out.println(x == y);  // false（两个不同对象）

// 案例3：混合场景
Integer m = Integer.valueOf(127);  // 缓存对象
Integer n = new Integer(127);      // 强制新建对象
System.out.println(m == n);        // false（不同对象）

---

三、其他包装类的缓存机制

3.1 各类型缓存范围

包装类	缓存范围	是否可配置
Byte	-128 ~ 127（全部值）	❌ 固定
Short	-128 ~ 127	❌ 固定
Integer	-128 ~ 127	✅ 可配置上限
Long	-128 ~ 127	❌ 固定
Character	\u0000 ~ \u007F（0~127）	❌ 固定
Boolean	true / false	❌ 固定（仅2个对象）
Float	无缓存	❌ 小数太多
Double	无缓存	❌ 小数太多

3.2 为什么Float和Double没有缓存？

// 浮点数在一个很小的范围内都有无穷多个值
// 例如：0.1, 0.11, 0.111, 0.1111, ...
// 无法预测哪些值会被频繁使用，缓存意义不大

3.3 Boolean的特殊实现

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

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);  // 永远返回这两个对象之一
}

// 使用示例
Boolean a = true;   // 指向Boolean.TRUE
Boolean b = true;   // 指向Boolean.TRUE
System.out.println(a == b);  // true

---

四、new Integer() vs Integer.valueOf()

4.1 核心区别

// 方式1：new关键字（不推荐）
Integer a = new Integer(100);  // ❌ 强制创建新对象，不走缓存

// 方式2：valueOf方法（推荐）
Integer b = Integer.valueOf(100);  // ✅ 优先使用缓存

// 方式3：自动装箱（本质调用valueOf）
Integer c = 100;  // ✅ 等价于Integer.valueOf(100)

4.2 对比验证

Integer a = new Integer(100);
Integer b = new Integer(100);
Integer c = 100;
Integer d = 100;

System.out.println(a == b);  // false（new强制创建不同对象）
System.out.println(c == d);  // true（缓存池同一对象）
System.out.println(a == c);  // false（一个是new的，一个是缓存的）

4.3 最佳实践

// ✅ 推荐写法
Integer num = 100;                 // 自动装箱，走缓存
Integer num2 = Integer.valueOf(100);  // 显式调用，走缓存

// ❌ 过时写法（JDK 9已标记@Deprecated）
Integer num3 = new Integer(100);   // 强制创建，浪费内存

---

五、如何调整Integer缓存范围？

5.1 JVM参数配置

# 将Integer缓存上限扩展到1000
java -XX:AutoBoxCacheMax=1000 YourApp

# 验证效果
Integer a = 500;
Integer b = 500;
System.out.println(a == b);  // 调整后为true

5.2 适用场景

// 业务场景：用户ID通常在1~10000之间
// 默认缓存（-128~127）：大量ID会创建新对象
// 扩展缓存（-128~10000）：大幅减少对象创建

// 配置启动参数
// -XX:AutoBoxCacheMax=10000

5.3 注意事项

• ⚠️ 仅Integer可配置，其他类型缓存范围固定
• ⚠️ 只能调整上限，下限固定为-128
• ⚠️ 上限不能超过 Integer.MAX_VALUE - 129
• ⚠️ 增大缓存会占用更多内存，需权衡

---

六、缓存池的应用与陷阱

6.1 正确使用

// ✅ 利用缓存提升性能
public void countFrequency(List<Integer> numbers) {
    Map<Integer, Integer> map = new HashMap<>();
    for (Integer num : numbers) {
        // 小数值频繁使用，自动走缓存，减少对象创建
        map.put(num, map.getOrDefault(num, 0) + 1);
    }
}

6.2 常见陷阱

陷阱1：误用 == 比较

Integer a = 200;
Integer b = 200;
if (a == b) {  // ❌ false，超出缓存范围
    // 永远不会执行
}

// 正确写法
if (a.equals(b)) {  // ✅ true
    // 正常执行
}

陷阱2：数据库ID比较

// 数据库返回的ID通常 > 127
Integer userId1 = userDao.getUserId("user1");  // 假设返回1001
Integer userId2 = userDao.getUserId("user2");  // 假设返回1001

if (userId1 == userId2) {  // ❌ false（不同对象）
    // 判断失败
}

// 正确写法
if (userId1.equals(userId2)) {  // ✅ true
    // 正常执行
}

陷阱3：Set去重失效

Set<Integer> set = new HashSet<>();
set.add(new Integer(100));  // 强制新建对象
set.add(new Integer(100));  // 又新建一个对象
// 虽然值相同，但HashSet通过equals()判断，能正确去重
System.out.println(set.size());  // 1（正确去重）

// 但如果自定义类未重写equals/hashCode
class User {
    int id;
    User(int id) { this.id = id; }
}
Set<User> users = new HashSet<>();
users.add(new User(100));
users.add(new User(100));
System.out.println(users.size());  // 2（去重失败！）

---

七、高频面试题

Q1: Java中的缓存池机制是怎么实现的？

答：

• 在包装类的静态内部类中，预先创建常用范围的对象数组
• 调用valueOf()时，先判断是否在缓存范围
• 范围内返回缓存对象，范围外创建新对象

Q2: 哪些类型用到了缓存池？范围分别是什么？

答：

• 整型：Byte/Short/Integer/Long → -128 ~ 127
• 字符型：Character → 0 ~ 127（ASCII字符）
• 布尔型：Boolean → true/false（仅2个对象）
• 浮点型：Float/Double → 无缓存

Q3: Integer缓存池的范围可以调整吗？如何调整？

答：

• 可以，通过JVM参数 -XX:AutoBoxCacheMax=1000
• 仅能调整上限，下限固定-128
• 其他类型不可配置

Q4: 为什么127之内的Integer相等，而超过127的不相等？

答：

Integer a = 127;
Integer b = 127;
a == b;  // true（缓存池同一对象）

Integer x = 128;
Integer y = 128;
x == y;  // false（超出缓存，两个不同对象）

Q5: new Integer(123) 和 Integer.valueOf(123) 有什么区别？

答：

方式	是否使用缓存	性能	推荐度
new Integer(123)	❌ 强制创建新对象	差	已废弃
Integer.valueOf(123)	✅ 优先缓存	好	推荐
Integer num = 123	✅ 自动调用valueOf	好	推荐

Q6: 为什么Float和Double没有缓存池？

答：

• 浮点数在任意区间都有无穷多个值（如0.1、0.11、0.111...）
• 无法预测哪些值会被频繁使用
• 缓存所有浮点数不现实，缓存少部分意义不大

---

八、最佳实践

✅ 推荐做法

// 1. 优先使用自动装箱
Integer num = 100;  // 而非 new Integer(100)

// 2. 包装类比较统一用equals()
Integer a = 200;
Integer b = 200;
if (a.equals(b)) { }  // 而非 a == b

// 3. 理解缓存范围，避免误判
if (num >= -128 && num <= 127) {
    // 此范围内的Integer对象可能被缓存复用
}

❌ 避免做法

// 1. 不要用new创建包装对象
Integer num = new Integer(100);  // 已废弃

// 2. 不要用 == 比较包装类
Integer a = 200;
Integer b = 200;
if (a == b) { }  // 错误，应该用equals()

// 3. 不要依赖缓存池做业务逻辑
if (num1 == num2) {  // 危险！可能因超出缓存范围而失败
    // 业务逻辑
}

---

相关链接

• 01-基本类型与包装类 - 8种基本类型与包装类对应关系
• 02-自动装拆箱 - valueOf()和intValue()的调用时机
• HashMap原理 - equals()和hashCode()如何影响缓存池对象的使用

---

记忆口诀

缓存池范围负一二八到一二七 Integer上限可调整，其余固定莫改变 valueOf走缓存，new方法强制建 包装比较用equals，不要依赖双等号

---

⬅️ 自动装拆箱 🏠 00-Java ➡️ 类型转换规则