java Float缓存机制

一、核心概念

❗ 关键结论：Float 没有自动缓存池（Cache Pool）

与 Integer 不同，Float 类在 JVM 中没有内置的缓存机制，即：

• Float.valueOf(float) 不会缓存 -128~127 或任何范围内的值。
• 每次调用 Float.valueOf(f) 都会创建一个新的 Float 对象（除非 JVM 做了特殊优化，但规范不保证）。
• == 比较两个 Float 对象几乎总是 false，即使值相同。

✅ 对比：Integer 有缓存，Float 没有

🔍 JVM 规范说明：

• Integer 的缓存是明确规定的（JLS §5.1.7）。
• Float 和 Double 没有类似规定，因此不应依赖缓存行为。

二、操作步骤（详细演示）

步骤 1：验证 Float 无缓存

public class FloatCacheTest {
    public static void main(String[] args) {
        // 创建两个相同的 Float 对象
        Float f1 = Float.valueOf(1.0f);
        Float f2 = Float.valueOf(1.0f);

        // 比较引用（==）
        System.out.println("f1 == f2: " + (f1 == f2)); // 输出: false

        // 比较值（equals）
        System.out.println("f1.equals(f2): " + f1.equals(f2)); // 输出: true

        // 使用 new 创建
        Float f3 = new Float(1.0f);
        System.out.println("f1 == f3: " + (f1 == f3)); // 输出: false
        System.out.println("f1.equals(f3): " + f1.equals(f3)); // 输出: true
    }
}

步骤 2：对比 Integer 有缓存

Integer i1 = Integer.valueOf(100);
Integer i2 = Integer.valueOf(100);
System.out.println("i1 == i2: " + (i1 == i2)); // true（缓存生效）

Integer i3 = Integer.valueOf(300);
Integer i4 = Integer.valueOf(300);
System.out.println("i3 == i4: " + (i3 == i4)); // 可能 false（超出缓存范围）

步骤 3：手动实现 Float 缓存（可选）

如果你确实需要缓存 Float 对象（例如性能敏感场景），可以手动实现：

import java.util.HashMap;
import java.util.Map;

public class FloatCache {
    private static final Map<Float, Float> cache = new HashMap<>();

    // 预加载常用值（如 0.0f, 1.0f, -1.0f 等）
    static {
        Float[] commonValues = {0.0f, -0.0f, 1.0f, -1.0f, 0.5f, 2.0f};
        for (Float f : commonValues) {
            cache.put(f, f);
        }
    }

    public static Float valueOf(float f) {
        return cache.getOrDefault(f, new Float(f));
    }

    public static void main(String[] args) {
        Float f1 = FloatCache.valueOf(1.0f);
        Float f2 = FloatCache.valueOf(1.0f);
        System.out.println("f1 == f2: " + (f1 == f2)); // true（手动缓存生效）
    }
}

三、常见错误

❌ 错误 1：误以为 Float 有缓存

Float f1 = 1.0f;
Float f2 = 1.0f;
if (f1 == f2) { ... } // ❌ 错误！可能为 false，不要依赖

正确做法：使用 .equals() 比较值。

❌ 错误 2：用 == 比较 Float 对象

Float a = Float.valueOf(2.5f);
Float b = Float.valueOf(2.5f);
if (a == b) { ... } // ❌ 危险！结果不确定

正确做法：

if (a.equals(b)) { ... } // ✅
// 或更安全（避免 null）：
if (Objects.equals(a, b)) { ... }

❌ 错误 3：混淆自动装箱与缓存

Float f = 1.0f; // 自动装箱，等价于 Float.valueOf(1.0f)
// 但依然不缓存！

四、注意事项

五、使用技巧

✅ 技巧 1：优先使用原始类型 float

// 好：性能高，无对象开销
float sum = 0.0f;
for (float value : array) {
    sum += value;
}

// 差：频繁装箱/拆箱
Float sum = 0.0f;
for (Float value : list) {
    sum += value; // 拆箱 + 装箱
}

✅ 技巧 2：集合中使用 float[] 或 TFloatList（Trove）

// 使用原始数组避免装箱
float[] values = new float[1000];

// 或使用高性能集合库（如 Trove）
// TFloatList list = new TFloatArrayList();

✅ 技巧 3：自定义缓存（仅限高频小集合）

// 缓存最常用的几个值
private static final Float ZERO = Float.valueOf(0.0f);
private static final Float ONE = Float.valueOf(1.0f);

六、最佳实践

1. ✅ 比较值用 .equals()，不用 ==
2. ✅ 性能敏感场景优先使用 float 而非 Float
3. ✅ 避免在循环中频繁装箱/拆箱
4. ✅ 使用 Objects.equals(a, b) 防止 NullPointerException
5. ✅ 理解 NaN、±0.0 的语义差异
6. ✅ 不要假设 Float.valueOf() 会复用对象

七、性能优化

性能测试示例（伪代码）

// 慢：装箱
List<Float> list = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
    list.add(i * 1.5f); // 装箱
}

// 快：原始数组
float[] arr = new float[1000000];
for (int i = 0; i < 1000000; i++) {
    arr[i] = i * 1.5f;
}

八、总结

✅ 一句话总结： Float 没有缓存！不要依赖 == 比较，优先使用原始 float 类型，性能和正确性更有保障。