java中INTEGER的取值范围详解

ja va中INTEGER的取值范围

在日常开发中，经常有人被 Integer 的 “==” 比较搞得晕头转向。先看一个典型例子：

public static void main(String[] args) {
    Integer a = new Integer(1);  // 注意：new 出来的对象，== 比较永远是 false
    int c = 1;
    Integer b = 1;
 
    System.out.println(a == c); // true  → 自动拆箱，比较的是值
    System.out.println(a == b); // false → 两个不同对象
        
    Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
        
    System.out.println(f1 == f2); // true
    System.out.println(f3 == f4); // false  → 咦？怎么又不相等了？

为什么 f3 == f4 是 false？

关键就在自动装箱背后的那个“缓存池”。Ja va 在编译时，Integer a = 100 会被翻译成 Integer a = Integer.valueOf(100)。而 valueOf 方法内部有一个缓存机制：默认只缓存 -128 到 127 之间的 Integer 对象。所以，100 在这个范围内，f1 和 f2 实际指向同一个缓存对象，用 == 比较返回 true。但 150 超出范围，每次调用 valueOf 都会新建一个对象，于是 f3 和 f4 是两个不同的对象，== 自然返回 false。

再看一段更详尽的代码，能帮助理清各种情况：

public class AutoboxingTest {
    public static void main(String args[]) {
        // 例1：基本类型 == 比较，值相等
        int i1 = 1;
        int i2 = 1;
        System.out.println("i1==i2 : " + (i1 == i2)); // true
 
        // 例2：混合类型比较（Integer vs int），自动拆箱
        Integer num1 = 1;
        int num2 = 1;
        System.out.println("num1 == num2 : " + (num1 == num2)); // true
 
        // 例3：自动装箱，且值在缓存范围内
        Integer obj1 = 1; // 实际调用 Integer.valueOf(1)
        Integer obj2 = 1; // 返回同一个缓存对象
        System.out.println("obj1 == obj2 : " + (obj1 == obj2)); // true
 
        // 例4：直接 new 对象，绝不走缓存
        Integer one = new Integer(1);
        Integer anotherOne = new Integer(1);
        System.out.println("one == anotherOne : " + (one == anotherOne)); // false
    }
}
 
Output:
i1==i2 : true
num1 == num2 : true
obj1 == obj2 : true
one == anotherOne : false

第三个例子算是个“极端情况”——两个自动装箱的 Integer 变量，竟然用 == 比较相等了。原因很简单：JVM 出于节省内存的考虑，会缓存 -128 到 127 的 Integer 对象。所以 obj1 和 obj2 实际上是指向同一个缓存对象。如果超出这个范围，那就只能乖乖走 new 了。

比较的时候，仍然是对象的比较

一旦数值不在 -128～127 范围内，记住：每次赋值都会 new 一个新对象，开辟新的内存空间，这些对象不属于 IntegerCache 的管理区。所以用 == 比较自然不相等。

还有一个容易踩坑的场景：

public static void main(String []args) {
    Integer a = 100;
    Integer b = a;   // b 指向与 a 相同的对象（值为100）
    a++;             // a 的值变为101，此时 a 指向新的 Integer 对象
                     // b 依然指向原来的100对象
    System.out.println(a == b); // false
}

打印结果是 false。因为 a 自增后，自动装箱机制又创建了一个新的 Integer 对象（值101），而 b 还在那儿指着老地址。

聊聊底层：一个 Integer 类型占 4 字节，共 32 位。除去第一位符号位，剩余 31 位表示数值。所以 最小值为 -2^31，最大值为 2^31 - 1。

如果 Integer 不是通过 new 创建，而是直接赋值（如 Integer b1 = 12; Integer b2 = 12;），这种情况会在常量池中开辟同一块空间来存储这个值，b1 和 b2 指向同一个地址。正因如此，才需要规定一个缓存范围。Ja va 语言规范（JSL）对这个范围做了明确约束：Integer 的缓冲范围为 -128 到 127。

在计算机中，数据是用二进制补码存储的。代码中看到的 0x80000000、0x7fffffff 其实都是补码形式，需要转成原码才能得到真实值。

转换公式：

• 正数：原码、反码、补码都相同。

例如正数1：
原码：0000 0000 0000 0000 0000 0000 0000 0001
反码：同上
补码：同上

• 负数：原码的符号位不变，其余位按位取反得到反码，反码加1得到补码。

总结

Integer 的缓存机制是个经典话题，理解 -128 到 127 这个范围以及自动装箱背后的 valueOf 调用，就能轻松解释各种“看上去奇怪”的 == 比较结果。日常开发中，比较 Integer 对象的值请务必使用 equals() 方法，或者先拆箱再比较。这样既安全，也不会被缓存“坑”到。