Java 中奇怪的整数装箱

Question

我刚刚看到类似这样的代码：

public class Scratch
{
    public static void main(String[] args)
    {
        Integer a = 1000, b = 1000;
        System.out.println(a == b);

        Integer c = 100, d = 100;
        System.out.println(c == d);
    }
}

当运行时，这段代码将打印出：

false
true

我明白为什么第一个是 false：因为这两个对象是单独的对象，所以 ==< /code> 比较引用。但我不明白，为什么第二个语句返回 true ？当整数的值在一定范围内时，是否会出现一些奇怪的自动装箱规则？这是怎么回事？

Answer 1

true 行实际上是由语言规范保证的。来自第 5.1.7 节：

如果装箱的值 p 为 true，
false，一个字节，一个范围内的字符
\u0000 到 \u007f，或者 int 或短整型
-128 到 127 之间的数字，然后令
r1 和 r2 是任意两个的结果
p的拳击转换。总是
r1 == r2 的情况。

讨论继续，表明虽然你的第二行输出是有保证的，但第一行却没有（参见下面引用的最后一段）：

理想情况下，对给定的原语进行装箱
值 p，总是会产生
相同的参考。在实践中，这
使用现有的可能不可行
实施技术。规则
以上是务实的妥协。这
上述最后条款要求
某些共同的值总是被装箱
变成无法区分的物体。这
实现可能会懒惰地缓存这些
或者热切地。

对于其他值，此公式
不允许任何有关的假设
盒装值的标识
程序员的部分。这将允许
（但不要求）共享一些或
所有这些参考资料。

这确保了在最常见的情况下
情况下，行为将是
想要的，而不强加不适当的
性能损失，尤其是
小型设备。内存限制较少
例如，实现可能是
缓存所有字符和短裤，如
以及整数和长整型
范围为-32K - +32K。

Answer 2

public class Scratch
{
   public static void main(String[] args)
    {
        Integer a = 1000, b = 1000;  //1
        System.out.println(a == b);

        Integer c = 100, d = 100;  //2
        System.out.println(c == d);
   }
}

输出：

false
true

是的，第一个输出是为了比较参考而产生的； 'a' 和 'b' - 这是两个不同的参考。在第 1 点中，实际上创建了两个引用，类似于 -

Integer a = new Integer(1000);
Integer b = new Integer(1000);

生成第二个输出是因为当 Integer 落入某个范围（从-128 至 127)。在第 2 点，没有为“d”创建 Integer 类型的新引用。它没有为整数类型引用变量“d”创建新对象，而是仅分配先前创建的由“c”引用的对象。所有这些都是由JVM完成的。

这些内存节省规则不仅适用于整数。出于节省内存的目的，以下包装器对象的两个实例（通过装箱创建时）将始终为 ==，其中它们的原始值相同 -

• 布尔
• 字节
• 从 \u0000 到 \ 的 字符u007f（7f 是十进制的 127）
• 短整型和整数，从 -128 到 127

Answer 3

整数缓存是 Java 版本 5 中引入的一项功能，主要目的是：

1. 节省内存空间
2. 提高性能。

Integer number1 = 127;
Integer number2 = 127;

System.out.println("number1 == number2" + (number1 == number2); 

输出： True

---

Integer number1 = 128;
Integer number2 = 128;

System.out.println("number1 == number2" + (number1 == number2);

输出： False

怎么办？

实际上，当我们为 Integer 对象赋值时，它会在幕后进行自动提升。

Integer object = 100;

实际上是调用Integer.valueOf()函数

Integer object = Integer.valueOf(100);

valueOf(int)的具体细节

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

描述：

此方法将始终缓存 -128 到 127 范围内的值，
包括在内，并且可能缓存此范围之外的其他值。

当需要 -128 到 127 范围内的值时，它每次都会返回一个恒定的内存位置。
但是，当我们需要一个大于 127 的值时，

return new Integer(i);

每次启动一个对象时都会返回一个新引用。

---

此外，Java 中的 == 运算符用于比较两个内存引用而不是值。

Object1 位于 1000 处，包含值 6。< br>
Object2 位于 1020，包含值 6。

Object1 == Object2 为 False，因为它们具有不同的内存位置，但包含相同的值。

Answer 4

某个范围内的整数对象（我认为可能是 -128 到 127）会被缓存并重新使用。超出该范围的整数每次都会获得一个新对象。

Answer 5

是的，有一个奇怪的自动装箱规则，当值在一定范围内时就会生效。当您将常量分配给对象变量时，语言定义中没有任何内容表明必须创建新对象。它可以重用缓存中的现有对象。

事实上，JVM 通常会为此目的存储小整数的缓存，以及 Boolean.TRUE 和 Boolean.FALSE 等值。

Answer 6

我的猜测是，Java 保留了已经“装箱”的小整数的缓存，因为它们非常常见，并且与创建新对象相比，重用现有对象可以节省大量时间。

Answer 7

这是一个有趣的观点。
在Effective Java一书中建议始终为您自己的类覆盖 equals 。另外，要检查 java 类的两个对象实例的相等性，请始终使用 equals 方法。

public class Scratch
{
    public static void main(String[] args)
    {
        Integer a = 1000, b = 1000;
        System.out.println(a.equals(b));

        Integer c = 100, d = 100;
        System.out.println(c.equals(d));
    }
}

返回：

true
true

Answer 8

将 int 文字直接分配给 Integer 引用是自动装箱的一个示例，其中文字值到对象转换代码由编译器处理。

因此，在编译阶段，编译器会将 Integer a = 1000, b = 1000; 转换为 Integer a = Integer.valueOf(1000), b = Integer.valueOf(1000);。

因此， Integer.valueOf() 方法实际上为我们提供了整数对象，如果我们查看 Integer.valueOf()方法我们可以清楚地看到方法缓存-128 到 127（含）范围内的整数对象。

/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

因此，如果传递的 int 文字大于 -128 且小于，则 Integer.valueOf() 该方法不会创建并返回新的整数对象，而是从内部 IntegerCache 返回 Integer 对象大于 127。Java

缓存这些整数对象，因为这个范围的整数在日常编程中被大量使用，从而间接节省了一些内存。

当类由于静态块而被加载到内存中时，缓存会在第一次使用时初始化。缓存的最大范围可以通过-XX:AutoBoxCacheMax JVM选项来控制。

这种缓存行为不仅仅适用于 Integer 对象，与 Integer.IntegerCache 类似，我们也有分别用于 Byte、Short、Long、Character 的 ByteCache、ShortCache、LongCache、CharacterCache。

您可以阅读我的文章 Java 整数缓存 - 为什么使用 Integer.valueOf(127) 来了解更多信息== Integer.valueOf(127) 为 True。

Answer 9

在 Java 中，整数的装箱范围在 -128 到 127 之间。当您使用此范围内的数字时，可以将其与 == 运算符进行比较。对于范围之外的 Integer 对象，您必须使用 equals。

Answer 10

如果我们检查Integer类的源代码，我们可以找到valueOf 方法就像这样：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

这解释了为什么 Integer 对象是在 -128 (Integer.low) 到 127 (Integer.high) 范围内，是自动装箱期间相同的引用对象。我们可以看到有一个类IntegerCache负责处理Integer缓存数组，它是Integer类的私有静态内部类。

还有另一个有趣的例子可能有助于理解这种奇怪的情况：

public static void main(String[] args) throws ReflectiveOperationException {
    Class cache = Integer.class.getDeclaredClasses()[0];
    Field myCache = cache.getDeclaredField("cache");
    myCache.setAccessible(true);

    Integer[] newCache = (Integer[]) myCache.get(cache);
    newCache[132] = newCache[133];

    Integer a = 2;
    Integer b = a + a;
    System.out.printf("%d + %d = %d", a, a, b); // The output is: 2 + 2 = 5
}

Answer 11

在 Java 5 中，引入了一项新功能来节省内存并提高整数类型对象处理的性能。整数对象在内部缓存并通过相同的引用对象重用。

1. 这适用于 –127 到 +127 范围内的整数值
   （最大整数值）。

2. 此整数缓存仅适用于自动装箱。整数对象将
   使用构造函数构建它们时不会被缓存。

有关更多详细信息，请访问以下链接：

整数缓存详细信息

Answer 12

Integer 类包含 -128 到 127 之间的值的缓存，这是 JLS 5.1.7。拳击转换。因此，当您使用 == 检查此范围内的两个 Integer 是否相等时，您会得到相同的缓存值，并且如果您比较两个 Integer< /code>s 超出此范围，您将得到两个不同的值。

您可以通过更改 JVM 参数来增加缓存上限：

-XX:AutoBoxCacheMax=<cache_max_value>

或

-Djava.lang.Integer.IntegerCache.high=<cache_max_value>

---

参见内部 IntegerCache 类：

/**
 * Cache to support the object identity semantics of autoboxing for values
 * between -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  The size of the cache
 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 * During VM initialization, java.lang.Integer.IntegerCache.high property
 * may be set and saved in the private system properties in the
 * sun.misc.VM class.
 */

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        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);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}