Java中的Integer缓存机制浅析：理解与避坑指南-原创手记-慕课网

优点与潜在问题简介

瑞典简介

Java 提供了一个 Integer 类，它封装了基本的 int 数据类型。Java 中的一个性能优化是整数缓存。本文将解释整数缓存是什么，它是如何工作的，以及可能出现的相关问题，并通过一些实际例子来说明。

什么是整数缓存？
Java会缓存 -128 到 127 范围内的整数对象。这意味着在这个范围内创建整数对象时，Java 使用缓存的对象而不是创建新的对象。这种优化有助于节省内存从而提高性能，尤其是在需要大量整数对象的情况下。

当你将 int 转换为 Integer 时，Java 会检查该值是否在缓存的范围内。如果是，它会返回缓存的对象。如果不是，它会创建一个新的 Integer 对象。

整数缓存的例子
让我们来看一个简单的例子来说明整数缓存。

    public class IntegerCacheExample {  
        public static void main(String[] args) {  
            Integer a = 100; // 自动包装整数  
            Integer b = 100; // 自动包装整数  
            Integer c = 200; // 自动包装整数  
            Integer d = 200; // 自动包装整数  

            System.out.println("a == b: " + (a == b) + "。"); // true，缓存实例  
            System.out.println("c == d: " + (c == d) + "。"); // false，新实例  
        }  
    }

解释如下

缓存值：当 a 和 b 被设置为 100 时，两者都指向同一个缓存的 Integer 实例，因此 a == b 返回 true。
非缓存值：当 c 和 d 被设置为 200 时，它们不在缓存范围内。因此，新的 Integer 对象会被创建，因此，c == d 的结果是 false。

整数缓存可能出现的问题

虽然整数缓存化是一种有用的优化，如果不正确理解，它可能导致意外结果。以下是几个常见问题：

1. 引用相等 vs. 值相等

由于缓存机制，开发人员可能会错误地使用引用相等（==）来比较 Integer 对象，而是应该使用 .equals() 方法来比较值是否相等。

例子比如

    Integer x = 127; // 缓存
    Integer y = 127; // 缓存

    System.out.println(x == y); // true

    Integer p = 128; // 新实例
    Integer q = 128; // 新实例

    System.out.println(p == q); // false
    System.out.println(p.equals(q)); // true

2. 集合中的异常行为

这非常重要。当使用如 HashSet 和 HashMap 这样的集合时，如果不了解缓存机制，依赖引用相等可能会导致意外情况。

例子:

    import java.util.HashMap;  

    public class IntegerCacheInHashMap {  
        public static void main(String[] args) {  
            // 创建一个HashMap来存储Integer键和String值  
            HashMap<Integer, String> map = new HashMap<>();  

            // 向map中添加值  
            Integer key1 = 100; // 缓存的实例  
            Integer key2 = 100; // 缓存的实例  
            Integer key3 = 200; // 新的实例  
            Integer key4 = 200; // 新的实例  

            // 添加条目  
            map.put(key1, "One Hundred");  
            map.put(key3, "Two Hundred");  

            // 查看引用相等性  
            System.out.println("检查引用相等性：");  
            System.out.println("map.get(key1): " + map.get(key1)); // "One Hundred"  
            System.out.println("map.get(key2): " + map.get(key2)); // "One Hundred" （相同值，缓存的实例）  

            // 查看新实例  
            System.out.println("\n查看新实例：");  
            System.out.println("map.get(key3): " + map.get(key3)); // "Two Hundred"  
            System.out.println("map.get(key4): " + map.get(key4)); // "Two Hundred" （相同值，不同对象）  

            // 检查键相等性  
            System.out.println("\n检查键相等性：");  
            System.out.println("key1 == key2: " + (key1 == key2)); // true，缓存的实例  
            System.out.println("key3 == key4: " + (key3 == key4)); // false，不同的对象  

            // 值相等性演示  
            System.out.println("\n值相等性演示：");  
            System.out.println("key3.equals(key4): " + key3.equals(key4)); // true，相同的数值  
        }  
    }

解释一下

添加：

我们创建了一个 HashMap 并添加了两个条目：一个键为缓存中的 100，另一个键为 200，该键超出了缓存的范围。
key1 和 key2 指向缓存中的同一个 100 实例，而 key3 和 key4 分别指向不同的 200 实例。

2. 获取值

当使用 key1 获取值时，它会返回 "One Hundred"，因为因为在映射中存在 key1。
同样使用 key2 获取会返回 "One Hundred"，因为它与 key1 持有相同的值，这表明映射根据键的值是否相等来决定是否返回相同的值。

三. 新的情况：

对于 key3，它成功检索到了 "Two Hundred"。
尽管这是一个不同的实例，它同样检索到了 "Two Hundred"，再次证明这个映射使用的是值的相等性。

4. 关键平等性

输出显示 key1 和 key2 引用上相等（都被缓存了），而 key3 和 key4 引用上不相等，因为它们是不同的对象实例。

5. 价值平等 ：

最后，使用 .equals() 检查时，key3 和 key4 是相等的，尽管它们是不同的对象。

最后的结论

这些改进的例子提供了对Java中整数缓存的含义及其影响的更清晰的理解。通过展示引用相等和值相等，以及这些概念在集合中的体现，你可以更好地理解在进行比较时使用.equals()的重要性，以及依赖==可能遇到的问题。