知识点
- 自动装箱和拆箱
- IntegerCache机制
- toString()实现算法优化
从一道面试题开始
Integer a = 100;
int b = 100;
if (a == b) {
System.out.println("a == b");
} else {
System.out.println("a != b");
}
聪明的你应该马上可以知道答案了，输出就是 a == b。
自动装箱和自动拆箱
那你可以说说自动装箱和拆箱是怎么回事吗？
把代码编程成字节码，很容易就可以看出来。在这里推荐Compiler Explorer这个小工具，在浏览器直接搜索就可以了。
当代码中声明Integer a = 100; 实际上在编译成的时候会自动转换成 Integer a = Integer.valueOf(100); 这个过程就是自动装箱。
当Integer类型和基础类型int在比较的时候，Integer类型会自动转换为int类型。a == b 实际上编译成 a.intValue() == b, 这个过程就是自动拆箱。 这个过程就是自动拆箱。
在上面的截图中，可以看过这个过程。
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.valueOf()方法，首先会检查需要变量i在不在IntegerCache范围内，如果有直接返回，没有则new一个出来。
Integer.intValue()
public int intValue() { return value; }
该方法非常简单，直接返回value。
IntegerCache
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() {}
}
上述代码的实现逻辑比较简单：
1、比较IntegerCache的取值范围，low是-128，high是127，其中high可以通过修改系统变量去设置。
2、创建一个cache数组，依次遍历创建Integer对象放到数组之中。
接着继续看看下面的程序会输出什么结果
Integer a = 128;
int b = 128;
if (a == b) {
System.out.println("a == b");
} else {
System.out.println("a != b");
}
Integer c = 128;
if (a == c) {
System.out.println("a == c");
}else {
System.out.println("a != c");
}
输出结果
a == b
a != c
解释一下：
a和b在比较的时候，a是Integer类型，b是int类型，a在编译的时候会自动拆箱，实际是 a.intValue() == b, 两个int之间的比较，实际上比较是数值，所以是相等的。
a和c在时间的时候，a和c都是Integer类型，不会发生自动拆箱，而是两个对象之间的比较，所以是不相等的。
趁热打铁，看看下面这两组
Integer d = 100;
Integer e = 100;
if (d == e) {
System.out.println("d == e");
}else {
System.out.println("d != e");
}
Integer m = new Integer(100);
Integer n = new Integer(100);
if (m == n) {
System.out.println("m == n");
}else {
System.out.println("m != n");
}
输出结果
d == e
m != n
解释
为什么d和e两个对象之间比较，输出结果是相等呢，这个就要说到IntegerCache机制了，在声明d和e的时候，编译时会自动装箱，也就是实际上时 Integer e = Integer.valueOf(100). 在默认情况下，IntegerCache的范围在-128-127. 所以d和e时相同的。而m和n强制使用new Integer去初始化变量，m和n返回的是不同的对象，所以是不相等的。
小结
1、自动装箱是发生在声明Integer变量时，且初始化表达式是个常量，会调用Integer.valueOf()方法，创建对象有IntegerCache机制。
2、自动拆箱时发生在Integer类型和int类型比较的时候， 会自动调用Integer.intValueOf()方法。
3、IntegerCache缓存机制默认范围是-128-127。
Integer.toString()实现
public static String toString(int i, int radix) {
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
radix = 10;
/* Use the faster version */
if (radix == 10) {
return toString(i);
}
char buf[] = new char[33];
boolean negative = (i < 0);
int charPos = 32;
if (!negative) {
i = -i;
}
while (i <= -radix) {
buf[charPos--] = digits[-(i % radix)];
i = i / radix;
}
buf[charPos] = digits[-i];
if (negative) {
buf[--charPos] = '-';
}
return new String(buf, charPos, (33 - charPos));
}
这段代码定义了一个方法，用于将长整型（long）数字转换为指定基数（radix）的字符串表示
1、基数检查，只有是2-36进制
2、10进制特殊处理
3、声明一个char数据，为什么是33呢，int类型是32位，加上’-'，所以一共是33
4、处理负数
5、while循环，计算余数和商，直到最后一个商小于基数的时候退出循环
6、处理最后一个商
7、处理负数
8、将char数组转换位String对象
public static String toString(int i) {
if (i == Integer.MIN_VALUE)
return "-2147483648";
int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
char[] buf = new char[size];
getChars(i, size, buf);
return new String(buf, true);
}
static void getChars(int i, int index, char[] buf) {
int q, r;
int charPos = index;
char sign = 0;
if (i < 0) {
sign = '-';
i = -i;
}
// Generate two digits per iteration
while (i >= 65536) {
q = i / 100;
// really: r = i - (q * 100);
r = i - ((q << 6) + (q << 5) + (q << 2));
i = q;
buf [--charPos] = DigitOnes[r];
buf [--charPos] = DigitTens[r];
}
// Fall thru to fast mode for smaller numbers
// assert(i <= 65536, i);
for (;;) {
q = (i * 52429) >>> (16+3);
r = i - ((q << 3) + (q << 1)); // r = i-(q*10) ...
buf [--charPos] = digits [r];
i = q;
if (i == 0) break;
}
if (sign != 0) {
buf [--charPos] = sign;
}
}
在上述代码中，比较引人注意的是有两个小片段
// Generate two digits per iteration
while (i >= 65536) {
q = i / 100;
// really: r = i - (q * 100);
r = i - ((q << 6) + (q << 5) + (q << 2));
i = q;
buf [--charPos] = DigitOnes[r];
buf [--charPos] = DigitTens[r];
}
这里使用了两个技巧。
第一个不再是用除以10去计算商，而是使用除以100，一次循环中计算两次
第二个是计算余数，不是使用%运算，也不是 r = i - (q * 100); 而是使用 r = i - ((q << 6) + (q << 5) + (q << 2));
这里没有使用乘法，而是使用左移和加法代替。
让我们逐步解释这个表达式：
q << 6：这是将 q 左移 6 位，相当于 q 乘以 (2^6 = 64)。
q << 5：这是将 q 左移 5 位，相当于 q 乘以 (2^5 = 32)。
q << 2：这是将 q 左移 2 位，相当于 q 乘以 (2^2 = 4)。
这三个位移操作分别模拟了 q 乘以 64、32 和 4。加在一起，它们就模拟了 q 乘以 100（因为 (64 + 32 + 4 = 100)）。
再来看另外一个片段
for (;;) {
q = (i * 52429) >>> (16+3);
r = i - ((q << 3) + (q << 1)); // r = i-(q*10) ...
buf [--charPos] = digits [r];
i = q;
if (i == 0) break;
}
首先，在计算商的时候并不是一个常规的除法运算。看到 q = (i * 52429) >>> (16+3); 这里并没有使用除法，代替的是 乘法 和 右移运算。
这行代码计算了i除以10的商。这里使用了52429这个特殊的数。这个数是通过100000 / 10（即10000除以10，再左移5位）得到的。这样，i * 52429相当于i乘以10000再左移5位。然后，通过无符号右移操作>>>来除以(2^19) （即右移19位），相当于再除以(2^14)（即65536）。这样，q就得到了i除以10的商的近似值。
由上面两个小片段中可以知道，在库函数级别的代码中，对代码和性能的要求非常高。
总结
1、自动装箱和拆箱 - 是一种语法糖，在编译器就实现。
2、IntegerCache机制 - 一种缓存机制，节约内存，避免对象重复创建。
3、toString()实现算法优化 - 使用位移算法替换乘法运算，使用乘法运算替换除法运算。
