源码详解java自动装箱拆箱

      装箱和拆箱是针对基本数据类型和引用数据类型相互转化，在java中，8种基本数据类型每一种都提供了一个包装类，例如int类型的包装类是Integer。包装类也包含了不少的静态实用的方法。下面我们就以整数类型为例，介绍自动装箱和自动拆箱

1、首先我们来看一下Integer的部分源码：

public final class Integer extends Number implements Comparable<Integer> {

	private final int value;
	
	//构造器
	public Integer(int value) {
        this.value = value;
    }

	//Integer类型对象调用该方法，返回int类型
	public int intValue() {
        return value;
    }
	
	//该静态方法可以将int类型转换为Integer对象类型
	public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)//注意这里有一个if判断，这里多了一个IntegerCache类
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
}

我们看一下IntegerCache这个类的源码：

//这是Integer类的内部类,而且被static修饰，也就是说，在虚拟机启动的时候，该类已经被加载到内存中
    private static class IntegerCache {
        static final int low = -128;//这里是定义的静态的final的low，为-128
        static final int high;
        static final Integer cache[];//一个静态的Integer类型的数组

        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() {}
    }

看了IntegerCache的源码后，我们了解到其实该类的作用就是为Integer做了一个包含-128~127的数组缓存，如果我们调用valueOf(int i)的方法，i的值在-128~127之间的话，就从IntegerCache中读取，不需要每次都创建新的对象。java这样设计目的可能就是为了减少内存提高效率。

2、在java5之前，int基本数据类型和Integer引用类型相互转换需要如下操作：

public class MyDemo {
    private static int a=2;

    public static void autoX() {
        Integer b = Integer.valueOf(a);//调用静态方法valueOf,将int转为Integer
        int c = b.intValue();//调用Integer.intValue()方法转为int类型
    }
}

      自动装箱和拆箱从Java 1.5开始引入，在java5后，如果一个int类型被传递到需要一个Integer对象的地方，那么编译器将在幕后插入一个对Integer.valueOf(int a)静态方法的调用，这就叫自动装箱。如果一个Integer对象被放到需要Int类型的地方，比编译器将在幕后插入一个对intValue方法的调用，这就叫自动拆箱。代码如下‘

public class MyDemo {
    private static int a=2;

    public static void autoX() {
        Integer b = a;//自动装箱
        int c = b;//自动拆箱
    }
}

3、自动装箱拆箱的应用：

      自动装箱和拆箱在Java中很常见，比如我们有一个方法，接受一个对象类型的参数，如果我们传递一个原始类型值，那么Java会自动将这个原始类型值转换成与之对应的对象。最经典的一个场景就是当我们向ArrayList这样的容器中增加原始类型数据时，比如下面的

public static void test() {
    List<Integer> list = new ArrayList<Integer>();
    list.add(3);
    list.add(33);

    int a = list.get(0);
}

注意：我们发现在自动装箱的过程中，编译器在幕后默认的执行了Integer.valueOf()方法，如果int类型的数字在-128~127之外的话，该方法内部会调用Integer构造方法创建对象，所以我们在应用的过程中，避免循环中过多的自动装箱操作，无形中消耗内存。