Java中变量类型可分为两类：根本类型和援用类型。根本类型有8种，别离是short，int，long，byte，char，float，double，boolean，同时也有8种援用类型作为其包装类，例如Integer，Double等。本文要探讨的就是这些根本类型和其包装类。
《2020最新Java根底精讲视频教程和学习路线！》

上面波及到源码的局部也仅仅列出局部有代表性的源码，不会有大段的代码。我应用的JDK版本是JDK1.8_144

1 Integer（整形）

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

[](https://imgchr.com/i/ilIpdA)

[

](https://imgchr.com/i/ilIpdA)

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包装类，对其源码进行了简略剖析，之所以没有对其余根本类型的保障类进行剖析是因为他们的实现十分类似，反复介绍就没有意思了。还简略探讨了一下主动装箱和主动拆箱，这个个性不便了程序员，进步了开发效率，但如果使用不当可能会造成令人蛊惑的问题，算是有利有弊吧。对于在根本类型和包装类型之间的抉择，我集体偏向于优先应用根本类型，起因也在文中有比拟具体的解释。