关于后端:Java-SE基础巩固一基本类型的包装类源码解读

4次阅读

共计 4486 个字符，预计需要花费 12 分钟才能阅读完成。

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

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

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 的源码之后，其余的都不难看懂。

主动装箱和主动拆箱是 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 个：

包装类型是一个类，要应用某个值就必须要创建对象，即便有缓存的状况下能够节俭创建对象的工夫开销，但空间开销依然存在，一个对象蕴含了对象头，实例数据和对象填充，但实际上咱们仅仅须要实例数据而已，对于 Integer 来说，咱们仅仅须要 value 字段的值而已，也就是说应用根本类型 int 只占用了 4 个字节的空间，而应用对象须要几倍于根本类型的空间（大家能够计算一下）。
接着第 1 条，对象是有可能为 null 的，这样在应用的时候有时候不得不对其进行空值判断，少数几个还好，当业务逻辑简单的时候（或者程序员写代码写上头的时候），就非常容易脱漏，一旦脱漏就很有可能产生空指针异样，如果没有紧密的测试，还真不肯定能测试进去。
包装类在进行比拟操作的时候有时候会让人蛊惑，咱们举个例子，假如有如下代码：
```
 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。

总之，如果能用根本类型，最好还是应用根本类型，而不是其包装类，如果切实无奈应用根本类型，例如容器的泛型类型参数，才应用包装类。

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

正文完