Java整数类中的加法运算

我在面试中得到一个Java问题，如下所示

public static boolean isSame(Integer a, Integer b){
 return a==b;
}

public static void main(String[] arg){
 int i=0;
 for(int j=0;i<500;++i,++j){
     if(isSame(i,j)){
         continue;
     }
     else break;
     }
}

公共静态布尔值ISNAME（整数a、整数b）{
返回a==b；
}
公共静态void main（字符串[]arg）{
int i=0；
对于（int j=0；i使用
=
比较两个
Integer
对象，如果它们是相同的对象（即相同的精确实例），则只会返回
true
，即不考虑它们的值

但是，值
-128
到
127
是缓存的，因此自动装箱这些值（当您将
int
作为
Integer
参数传入时发生）对于给定值总是返回相同的
Integer
实例

超出此范围的值总是导致创建一个新的
整数实例。
这是因为自动装箱

如果要装箱的值p为true、false、一个字节、一个\u0000到\u007f范围内的字符或一个介于-128和127之间的整数或短数，则让r1和r2成为p的任意两个装箱转换的结果。r1==r2的情况始终如此

要了解有关自动装箱的更多信息，请参阅此处


源代码：

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) {
            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);
        }
        high = h;

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

    private IntegerCache() {}
}

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

私有静态类整型缓存
{
静态最终整数低=-128；
静态最终int高；
静态最终整数缓存[]；
静止的{
//高值可由属性配置
int h=127；
字符串整数CacheHighPropValue=
sun.misc.VM.getSavedProperty（“java.lang.Integer.IntegerCache.high”）；
if（integerCacheHighPropValue！=null）{
int i=parseInt（integerCacheHighPropValue）；
i=数学最大值（i，127）；
//最大数组大小为整数。最大值为
h=数学最小值（i，整数最大值-（-low）-1）；
}
高=h；
缓存=新整数[（高-低）+1]；
int j=低；
for（int k=0；k=127；
如果（i>=IntegerCache.low&&i保证缓存-128..127，但也声明“内存限制较少的实现可能会缓存所有字符和短值，以及-32K到+32K范围内的int和long值。”因此最好不要依赖外部的值。因此，此OP访谈问题的正确答案是“依赖于实现”（可能需要附加注释“但至少128”-128，因为它比最大缓存值多一个）@ErwinBolwidt是的。这个问题要么设计糟糕，要么实际上非常好。似乎还添加了更改缓存大小的设置。