自动装箱与拆箱

默认值	存储需求（字节）	取值范围	示例
byte	0	1	-2^7—2^7-1	byte b=10;
char	‘ \u0000′	2	0—2^16-1	char c=’c’ ;
short	0	2	-2^15—2^15-1	short s=10;
int	0	4	-2^31—2^31-1	int i=10;
long	0	8	-2^63—2^63-1	long o=10L;
float	0.0f	4	-2^31—2^31-1	float f=10.0F
double	0.0d	8	-2^63—2^63-1	double d=10.0;
boolean	false	1	true\false	boolean flag=true;

自动装箱与拆箱

  Integer a=new Integer(1);
      Integer b=1;
      Integer c=Integer.valueOf(1);
     System.out.println(""+(a == b)+(a == c)+(b == c));

输出结果为 false,false,true。
说明：只要是new出来的对象，不管前后位置，用 == 比都是比较引用，都为false.

下列 java 程序输出结果为______。

1 2 3 4

int i= 0 ; Integer j = new Integer( 0 ); System.out.println(i==j); System.out.println(j.equals(i）)

i==j ，这个是基本类型与 Integer 的比较，j会自动拆箱成int类型，然后比较的是值。因此返回真。

j.equals(i) ，调用 equals 方法后，这个i会自动装箱成Integer类型，然后再比较值，所以也返回真。

 首先看一段代码（使用JDK 5），如下：

[html]  view plain  copy

1. public class Hello   
2. {   
3.   public static void main(String[] args)   
4.   {   
5.     int a = 1000, b = 1000;   
6.     System.out.println(a == b);   
7.   
8.     Integer c = 1000, d = 1000;   
9.     System.out.println(c == d);   
10.   
11.     Integer e = 100, f = 100;   
12.     System.out.println(e == f);   
13.   }   
14. }   

输出结果：

[html]  view plain  copy

1. true  
2. false  
3. true  

The Java Language Specification, 3rd Edition 写道：

[html]  view plain  copy

1. 为了节省内存，对于下列包装对象的两个实例，当它们的基本值相同时，他们总是==：  
2.  Boolean  
3.  Byte  
4.  Character, \u0000 - \u007f(7f是十进制的127)  
5.  Integer, Long -128 — 127  

查看jdk源码，如下：

[java]  view plain  copy

1. /** 
2.      * Cache to support the object identity semantics of autoboxing for values between  
3.      * -128 and 127 (inclusive) as required by JLS. 
4.      * 
5.      * The cache is initialized on first usage. During VM initialization the 
6.      * getAndRemoveCacheProperties method may be used to get and remove any system 
7.      * properites that configure the cache size. At this time, the size of the 
8.      * cache may be controlled by the vm option -XX:AutoBoxCacheMax=<size>. 
9.      */  
10.   
11.     // value of java.lang.Integer.IntegerCache.high property (obtained during VM init)  
12.     private static String integerCacheHighPropValue;  
13.   
14.     static void getAndRemoveCacheProperties() {  
15.         if (!sun.misc.VM.isBooted()) {  
16.             Properties props = System.getProperties();  
17.             integerCacheHighPropValue =  
18.                 (String)props.remove("java.lang.Integer.IntegerCache.high");  
19.             if (integerCacheHighPropValue != null)  
20.                 System.setProperties(props);  // remove from system props  
21.         }  
22.     }  
23.   
24.     private static class IntegerCache {  
25.         static final int high;  
26.         static final Integer cache[];  
27.   
28.         static {  
29.             final int low = -128;  
30.   
31.             // high value may be configured by property  
32.             int h = 127;  
33.             if (integerCacheHighPropValue != null) {  
34.                 // Use Long.decode here to avoid invoking methods that  
35.                 // require Integer's autoboxing cache to be initialized  
36.                 int i = Long.decode(integerCacheHighPropValue).intValue();  
37.                 i = Math.max(i, 127);  
38.                 // Maximum array size is Integer.MAX_VALUE  
39.                 h = Math.min(i, Integer.MAX_VALUE - -low);  
40.             }  
41.             high = h;  
42.   
43.             cache = new Integer[(high - low) + 1];  
44.             int j = low;  
45.             for(int k = 0; k < cache.length; k++) //缓存区间数据  
46.                 cache[k] = new Integer(j++);  
47.         }  
48.   
49.         private IntegerCache() {}  
50.     }  
51.   
52.     /** 
53.      * Returns a <tt>Integer</tt> instance representing the specified 
54.      * <tt>int</tt> value. 
55.      * If a new <tt>Integer</tt> instance is not required, this method 
56.      * should generally be used in preference to the constructor 
57.      * {@link #Integer(int)}, as this method is likely to yield 
58.      * significantly better space and time performance by caching 
59.      * frequently requested values. 
60.      * 
61.      * @param  i an <code>int</code> value. 
62.      * @return a <tt>Integer</tt> instance representing <tt>i</tt>. 
63.      * @since  1.5 
64.      */  
65.     public static Integer valueOf(int i) {  
66.         if(i >= -128 && i <= IntegerCache.high)  
67.             return IntegerCache.cache[i + 128];  
68.         else  
69.             return new Integer(i);  
70.     }  

这儿的IntegerCache有一个静态的Integer数组，在类加载时就将-128 到 127 的Integer对象创建了，并保存在cache数组中，一旦程序调用valueOf 方法，如果i的值是在-128 到 127 之间就直接在cache缓存数组中去取Integer对象。若为new关键字，则在heap中开辟了一块新内存放置Integer对象，其应用不指向cache数组。

再看其它的包装器：

• Boolean：(全部缓存)
• Byte：(全部缓存)
• 
  
• Character(<= 127缓存)
  
• Short(-128 — 127缓存)
• Long(-128 — 127缓存)
  
• 
  
• Float(没有缓存)
• Doulbe(没有缓存)
  

同样对于垃圾回收器来说：

[java]  view plain  copy

1. Integer i = 100;     
2. i = null;//will not make any object available for GC at all.  

这里的代码不会有对象符合垃圾回收器的条件，这儿的i虽然被赋予null，但它之前指向的是cache中的Integer对象，而cache没有被赋null，所以Integer(100)这个对象还是存在。

而如果i大于127或小于-128则它所指向的对象将符合垃圾回收的条件：

[java]  view plain  copy

1. Integer i = 10000;     
2. i = null;//will make the newly created Integer object available for GC.