Java自动装箱的陷阱

Java的自动拆箱和装箱是Java语言的一颗语法糖。在之前的学习中有很多误解，在别人的帮助下作出一些修正。先看下面的代码：

 1 public static void main(String args[]) {
 2         Integer a = 1;
 3         Integer b = 2;
 4         Integer c = 3;
 5         Integer d = 3;
 6         Integer e = 321;
 7         Integer f = 321;
 8         Long g = 3L;
 9         int x = 3;
10         long y = 3L;
11         
12         //x,y虽然类型不同但是可以直接进行数值比较
13         System.out.println(x == y);
14         //System.out.println(c == g); 提示出错，不可比较的类型。说明此时没有自动拆箱
15         System.out.println(c == d);
16         System.out.println(e == f);
17         System.out.println(c == (a+b));
18         System.out.println(c.equals(a+b));
19         //此时进行了自动的拆箱
20         System.out.println(g == (a+b));
21         System.out.println(g.equals(a+b));
22     }

答案是：

这样的答案是不是出乎很多人的意料呢？我们一一来分析。

1. 首先我们明确一下"=="和equals方法的作用。

　　"=="：如果是基本数据类型，则直接对值进行比较，如果是引用数据类型，则是对他们的地址进行比较（但是只能比较相同类型的对象，或者比较父类对象和子类对象。类型不同的两个对象不能使用==）

　　equals方法继承自Object类，在具体实现时可以覆盖父类中的实现。看一下Object中qeuals的源码发现，它的实现也是对对象的地址进行比较，此时它和"=="的作用相同。而JDK类中有一些类覆盖了Object类的equals()方法，比较规则为：如果两个对象的类型一致，并且内容一致，则返回true,这些类有：
java.io.file,java.util.Date,java.lang.string，包装类（Integer,Double等）。

2. Java的包装类实现细节。观察源码会发现Integer包装类中定义了一个私有的静态内部类如下：

 1 private static class IntegerCache {
 2     static final int low = -128;
 3     static final int high;
 4     static final Integer cache[];
 5 
 6     static {
 7         // high value may be configured by property
 8         int h = 127;
 9         String integerCacheHighPropValue =
10             sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
11         if (integerCacheHighPropValue != null) {
12             try {
13                 int i = parseInt(integerCacheHighPropValue);
14                 i = Math.max(i, 127);
15                 // Maximum array size is Integer.MAX_VALUE
16                 h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
17             } catch( NumberFormatException nfe) {
18                 // If the property cannot be parsed into an int, ignore it.
19             }
20         }
21         high = h;
22 
23         cache = new Integer[(high - low) + 1];
24         int j = low;
25         for(int k = 0; k < cache.length; k++)
26             cache[k] = new Integer(j++);
27 
28         // range [-128, 127] must be interned (JLS7 5.1.7)
29         assert IntegerCache.high >= 127;
30     }
31 
32     private IntegerCache() {}
33 }

而Integer的自动装箱代码：

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

通过观察上面的代码我们可以发现，Integer使用一个内部静态类中的一个静态数组保存了-128-127范围内的数据，静态数组在类加载以后是存在方法区的，并不是什么常量池。在自动装箱的时候，首先判断要装箱的数字的范围，如果在-128-127的范围则直接返回缓存中已有的对象，否则new一个新的对象。其他的包装类也有类似的实现方式，可以通过源码观察一下。

3. "=="在遇到非算术运算符的情况下不会自动拆箱，以及他们的equals方法不处理数据类型转换的关系。

因此，对于 System.out.println(c == d); 他们指向同一个对象，返回True。

对于 System.out.println(e == f); 他们的值大于127，即使值相同，但是对应不同的内存地址，返回false。

对于 System.out.println(c == (a+b)); 自动拆箱后他们的值是相等的，返回True。

对于 System.out.println(c.equals(a+b)); 他们的值相同，而且类型相同，返回true。

对于 System.out.println(g == (a+b)); 自动拆箱后他们的值相等，返回True。

对于 System.out.println(g.equals(a+b)); 他们的值相同但是类型不同，返回false。

4. 总结

对于不懂的地方，最好是通过阅读源码的方式来解决。这样才能真正明白内部的一些实现方式。