Java SE基础巩固（一）：基本类型的包装类源码解读

Java中变量类型可分为两类：基本类型和引用类型。基本类型有8种，分别是short，int，long，byte，char，float，double，boolean，同时也有8种引用类型做为其包装类，例如Integer，Double等。本文要讨论的就是这些基本类型和其包装类。

下面涉及到源码的部分也仅仅列出部分有表明性的源码，不会有大段的代码。我使用的JDK版本是JDK1.8_144

1 Integer（整形）

Integer是基本类型int的包装类型。下图是其继承体系：

Integer继承了Number类，实现了Comparable便可，拥有可比较的能力，还间接的实现了Serializable接口，便是可序列化的。实际其余几个数字相关的包装类型都是这么一个继承体系，因此若是下文中没有特殊说明，就表示继承体系和Integer同样。

先来看看valueOf()方法，在Integer类里有三个重载的valueOf()方法，但最终都会调用public static Integer valueOf(int i)。下面是public static Integer valueOf(int i)的源码：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
复制代码

能够看到，该方法接受一个基本类型int参数，并返回一个Integer对象，须要注意的是那个if判断，这里会判断这个i是否在[IntegerCache.low,IntegerCache.high]区间里，若是在就直接返回缓存值，那这个low和hight的值是多少呢？咱们到IntegerCache类里看看：

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        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() {}
    }
复制代码

这是Integer的一个内部静态类，从代码中，不难看出low的值是-128，high的值默认是127，其中high值能够经过java.lang.Integer.IntegerCache.high属性来设置，这个类的逻辑代码几乎都在static块里，也就是说在类加载的时候会被执行了，执行的结果是什么呢？关注这几行代码：

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

将区间在[low,hight]的值都构形成Integer对象，并保存在cache数组里。这时候再回头看看valueOf()方法，发现若是参数i的值在[low,hight]区间里，那么就会返回cache里对应的Integer对象，话句话说，若是参数在这个区间范围里，那么调用该方法的时候就不须要建立对象了，直接使用缓存里的对象，减小了建立对象的开销。

那为何要搞这么复杂呢？由于Java5提供了自动装箱和自动拆箱的语法糖，而这个方法其实就是为自动装箱服务的（从注释能够看到，这个方法从java5才开始有的，由此可推断应该和自动装箱拆箱机制有关），Integer是一个很是经常使用的类，有了这个缓存机制，就不须要每次在自动装箱或者手动调用的时候建立对象了，大大提升了对象复用率，也提供了运行效率。[-128，127]是一个比较保守的范围，用户能够经过修改java.lang.Integer.IntegerCache.high来修改high值，但最好不要太大，由于毕竟Intger对象也是要占用很多内存的，若是上界设置的太大，而大的值又不常用，那么这个缓存就有些得不偿失了。

再来看看另外一个方法intValue()，这个方法就很是简单了：

public int intValue() {
        return value;
    }
复制代码

value是Integer类的私有字段，类型是int，就是表明了实际的值，该方法实际上就是自动拆箱的时候调用的方法。

其余方法就没什么可说的了，大多数是一些功能性的方法（例如max，min，toBinaryString）和一些常量（例如MAX_VALUE，MIN_VALUE），感兴趣的朋友能够自行查看，算法逻辑也都不难。

其余几个就很少说了，在理解了Integer的源码以后，其余的都不难看懂。

2 自动装箱和自动拆箱

自动装箱和自动拆箱是Java5提供的语法糖，当咱们须要在基本类型和包装类之间进行比较、赋值等操做的时候，编译器会帮咱们自动进行类型转换，装箱就是将基本类型转换成包装类型，拆箱就是与之相反的一个过程。例如，咱们有下面这样的代码：

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    int a = 1, b = 2, c = 3;
    list.add(a);
    list.add(b);
    list.add(c);
}
复制代码

编译后的.class文件内容以下（作了转码的，实际上.class文件应该是字节码，但为了方便查看，就将其转成了java代码的形式）：

public static void main(String[] var0) {
    ArrayList var1 = new ArrayList();
    byte var2 = 1;
    byte var3 = 2;
    byte var4 = 3;
    var1.add(Integer.valueOf(var2));
    var1.add(Integer.valueOf(var3));
    var1.add(Integer.valueOf(var4));
}
复制代码

这里就发生了装箱操做，编译器帮咱们调用了Integer.valueOf()方法将int类型转换了Integer类型以适应List容器（容器的类型参数不能是基本类型）。

拆箱也相似，只是方向和装箱相反而已，通常发生在将包装类型的值赋值给基本类型时候，例如：

Integer a = 1;
int b = a; //自动拆箱
复制代码

若是没有自动拆箱，上面的代码确定是没法编译经过，由于类型不匹配，又没有进行强转。

关于自动装箱和拆箱更多的内容，网上有不少资料（很是很是多），建议有兴趣的朋友能够到网上搜索搜索。

3 选择基本类型仍是包装类型呢？

首先，咱们先明确一个基本原则：若是某个场景中不能使用基本类型和包装类型的其中一种，那么就只能选择另一种。例如，容器的泛型类型参数不能是基本类型，那就不要有什么犹豫了，直接使用包装类型吧。

当两种类型均可用的时候，建议使用基本类型，主要缘由有以下3个：

1. 包装类型是一个类，要使用某个值就必需要建立对象，即便有缓存的状况下能够节省建立对象的时间开销，但空间开销仍然存在，一个对象包含了对象头，实例数据和对象填充，但实际上咱们仅仅须要实例数据而已，对于Integer来讲，咱们仅仅须要value字段的值而已，也就是说使用基本类型int只占用了4个字节的空间，而使用对象须要几倍于基本类型的空间（你们能够计算一下）。

2. 接着第1条，对象是有可能为null的，这样在使用的时候有时候不得不对其进行空值判断，少数几个还好，当业务逻辑复杂的时候（或者程序员写代码写上头的时候），就很是容易遗漏，一旦遗漏就颇有可能发生空指针异常，若是没有严密的测试，还真不必定能测试出来。

3. 包装类在进行比较操做的时候有时候会让人迷惑，咱们举个例子，假设有以下代码：

   public static void main(String[] args) {
           Integer d = 220;  
           Integer e = 220;
           int f = 220;
           System.out.println(d == e);
           System.out.println(e == f);
       }
   复制代码

   若是没有遇到过这样的问题，可能下意识的说出执行的结果是true和true，但实际上，输出的结果是false，true。为何？对于第一个比较，d和e都是Integer对象，直接用==比较的实际上引用的值，而不是实际的值，在将220赋值给她们的时候实际上发生过自动装箱，即调用过valueOf()方法，而220超出了默认的缓存区间，那么就会建立新的Interge对象，这两个a和b的引用确定就不相等，因此会输出false。第二个比较中，f是基本类型，在这里状况下，会发生自动拆箱，==两边的变量实际上基本类型int，直接比较时没有问题的，因此输出结果会是true。

总之，若是能用基本类型，最好仍是使用基本类型，而不是其包装类，若是实在没法使用基本类型，例如容器的泛型类型参数，才使用包装类。

4 小结

本文介绍了Integre包装类，对其源码进行了简单分析，之因此没有对其余基本类型的保证类进行分析是由于他们的实现很是类似，重复介绍就没有意思了。还简单讨论了一下自动装箱和自动拆箱，这个特性方便了程序员，提升了开发效率，但若是使用不当可能会形成使人迷惑的问题，算是有利有弊吧。对于在基本类型和包装类型之间的选择，我我的倾向于优先使用基本类型，缘由也在文中有比较详细的解释。