今天打算复习一下Java基础，之前学的太快速了，现在暑假，好好把那些细节看一下

复习到自动装箱和自动拆箱的时候，这里有个很有趣的现象

1. Integer n1 = 100;   
2. Integer n2 = 100;    
3. System.out.println(n1 == n2);      
4.  
5. Integer n3 = 200;    
6. Integer n4 = 200;    
7. System.out.println(n3 == n4);   

你们猜猜结果是什么  第一个是true，第二个是false。有趣吧。

其实它们是相当于

1. Integer n1 = Integer.valueOf(100);      
2. Integer n2 = Integer.valueOf(100);     
3. System.out.println(n1 == n2);    
4.  
5. Integer n1 = Integer.valueOf(200);      
6. Integer n2 = Integer.valueOf(200);     
7. System.out.println(n1 == n2);     
8.    

所以那个valueOf()就是问题的关键啦，看一下这个函数的源码

1. /**    
2.   * Returns an {@code Integer} instance representing the specified    
3.   * {@code int} value.  If a new {@code Integer} instance is not    
4.   * required, this method should generally be used in preference to    
5.   * the constructor {@link #Integer(int)}, as this method is likely    
6.   * to yield significantly better space and time performance by    
7.   * caching frequently requested values.    
8.   *    
9.   * This method will always cache values in the range -128 to 127,    
10.   * inclusive, and may cache other values outside of this range.    
11.   *    
12.   * @param  i an {@code int} value.    
13.   * @return an {@code Integer} instance representing {@code i}.    
14.   * @since  1.5    
15.   */    
16.  public static Integer valueOf(int i) {     
17.      assert IntegerCache.high >= 127;     
18.   if (i >= IntegerCache.lo&&i<=IntegerCache.high)          
19.  return IntegerCache.cache[i + (-IntegerCache.low)];     
20.      return new Integer(i);     
21.  }    

所以我们知道了，对于-128到127之间的数,Integer.valueOf(99)返回的是缓存中的对象,所以两次调用valueOf返回的是同一个对象,故结果是true.而Integer.valueOf(199)返回的则是重新实例化的对象,故结果是false.

自动拆箱

1. Integer n1 = 10;  
2. int t1 = n1;  
3. Integer n2 = 10;  
4. int t2 = n2;  
5. System.out.println(t1 == t2); 

1. Integer n1 = 199;  
2. int t1 = n1;  
3. Integer n2 = 199;  
4. int t2 = n2;  
5. System.out.println(t1 == t2); 

两次的结果是true。

所以我们要注意自动装箱时候数值的范围的选择~~