Java的自动包装、拆箱。

基本类型转到其他的包装类，在该过程中会有自动包装机制。相反，由其他包装类到基本数据类型，会有自动拆箱。他们的实际工作到底是怎样执行的呢？下面我们来分析一下。

先模拟最常见的关于整型的自动包装和自动拆箱，看看他们的字节码。

package demo1;

public class demo {
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer a = 1;
		int b = a ;

	}
}

字节码部分

OK，根据字节码我能很明显的可以看到：

int类型包装为Integer类型，会自动调用 Integer.valueOf（）函数;

Integer类型拆箱为int类型，自动调用Integer.()函数；

我们下来看下Java中是如何实现这两个函数的

	//这是自动包装时执行的函数
    public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
            return new Integer(i);
    }

根据valueOf()函数我们发现，当一个数在-128~127之间的时候，返回的同一个东西(因为没有new)，而不再此范围则会new一个Integer返回。OK，让我们继续看看IntegerCache是什么 ？

    private static class IntegerCache {
        static final int high;
        static final Integer cache[];

        static {
            final int low = -128;

            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

发现，IntegerCache是一个静态内部类。根据他的定义，我们可知道在  -128-127(默认情况下)的范围内，Integer(-127)~Integer（127）被保存在一个数组之中；根据valueOf()里面的代码我们可以知道下面一个事实：

当在-128~127的范围内，某个数值的Integer对象都指向同一个地址；在此范围外，都指向不同的地址；由于我们知道==是比较两个数据的地址，所以，在Java里面会出现如下情况：

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer a = 1;
		Integer b =2;
		Integer c = 3;
    	        Integer d = 3;
		Integer e = 128;
		Integer f = 128;

        	System.out.println(c == d);
        	System.out.println(e == f);
		System.out.println(c == (a+b));
		
	
	}

输出结果：

true
false
true

对于这种结果，大家应该知道怎么回事了吧？

下来说说关于equal的问题。Integer的equal函数实现如下：

   public boolean equals(Object obj) {
	if (obj instanceof Integer) {
	    return value == ((Integer)obj).intValue();
	}
	return false;
    }

对于equals函数我们知道先判断是否为Integer类型，是的话再继续去判断他的数值是否相等。

---------------------------------------------------------------------------------------------------分割线-------------------------------------------------------------------------------------------

在这块，还有些值得注意的地方：

1.在执行运算时，会自动执行自动拆箱和包装。比如：

  

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer a = 1;
		Integer b =2;
		Integer c = 3;
		Long g = 3L;
		System.out.println(c ==(a+b));
	}

在执行 a+b时，会自动的拆箱为int类型，比如：

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer a = 1;
		Integer b =2;
		Integer c = 3;
	    System.out.println(c.equals(a+b));
	    //报错。
	    System.out.println((a+b).equals(c));
	
	}
	

2.不同类型之间的转换问题。（待解决）

public class demo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer a = 1;
		Integer b =2;
		Long g = 3L;
		//报错
	//	System.out.println(a==g);
		System.out.println((a+b)==g);
		System.out.println(g.equals(a+b));
		//报错
	//	System.out.println((a+b).equals(g));
	}

析:

第一个报错：以前一直只知道 == 是比较两个对象的地址，按理不同类型的对象可以直接比较，只要地址不对返回false就行。但是编译器会报错；但两遍比较的对象存在直接或间接的继承关系则不会。（==的约束是什么？没搞明白。）

第二个true：a+b被拆箱为int类型，g被拆想为float类型，==对于基本类型直接比较数值。

第三个false：a+b先被拆箱为int，再被包装为integer，integer不是float，直接返回false；

第四个报错：（a+b）为int，没有方法可调用。

至于其他的类型的自动包装和拆箱，大家可以自己分析。