// 手动装箱
Integer integer = new Integer(10);
// 手动拆箱
int i = integer.intValue();
// 自动装箱,通过 Integer.valueOf() 完成
Integer integer = 10;
// 自动拆箱,通过 Integer.intValue() 完成
int i = integer;
- IntegerCache
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
private static class IntegerCache {
// 缓存的最小值,默认为 -128
static final int low = -128;
// 缓存的最大值,默认为 127,但可以通过 JVM 参数配置
static final int high;
static final Integer cache[];
static {
// 默认情况下 high 值为 127
int h = 127;
// 通过系统属性获取用户可能配置的更高的缓存上限
// integerCacheHighPropValue 是一个字符串,代表配置的高值
int i = parseInt(integerCacheHighPropValue);
// 确保缓存的最高值至少为 127
i = Math.max(i, 127);
// 设置 high 的值,但不能超过 Integer.MAX_VALUE - (-low) - 1
h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);
high = h;
// 初始化缓存数组,大小为 high - low + 1
cache = new Integer[(high - low) + 1];
// 填充缓存,从 low 开始,为每个值创建一个 Integer 对象
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// 断言确保 high 的值至少为 127,这是 Java 语言规范要求的
assert IntegerCache.high >= 127;
}
}
int a = 100;
Integer b = 100;
// 基本数据类型和包装类型进行 == 比较,这时候 b 会自动拆箱,直接和 a 比较值
// true
System.out.println(a == b);
// -128 到 127 之间的数会从 IntegerCache 中取,然后比较,100 在这个范围之内
Integer c = 100;
Integer d = 100;
// true
System.out.println(c == d);
// 200 不在这个范围之内,所以 new 出来了两个 Integer 对象
c = 200;
d = 200;
// false
System.out.println(c == d);
- 当需要进行自动装箱时,如果数字在 -128 至 127 之间时,会直接使用缓存中的对象,而不是重新创建一个对象
- 反例
long t1 = System.currentTimeMillis();
Long sum = 0L;
// sum 是个 Long 型,而 i 为 int 类型
for (int i = 0; i < Integer.MAX_VALUE;i++) {
// 先把 i 强转为 long 型,然后再把 sum 拆箱为 long 型进行相加操作
// 之后再自动装箱为 Long 型赋值给 sum
sum += i;
}
long t2 = System.currentTimeMillis();
System.out.println(t2-t1);
标签:拆箱,缓存,int,high,low,127,Integer,装箱
From: https://www.cnblogs.com/sprinining/p/18301486