Java基本数据类型及其封装器的一些千丝万缕的纠葛

一些概念

想必大家都知道Java的基础数据类型有：char、byte、short、int、long、float、double、boolean 这几种，与C/C++等语言不同的是，Java的基础数据的位数是固定不变的。
    Java作为一门面向对象的语言，自然少不了对象了，因此基础数据类型都对应存在一个基本类型封装器类，它们的封装器分别为：Character、Byte、Short、Integer、Long、Float、Double、Boolean。
    在JDk1.5之前，在基础数据类型与其封装器之间的转化必须手动进行，其中将基本数据类型转换为封装器类型需要调用封装类的静态方法T.valueOf()，T代表封装器类型的名称，而将封装器类型转换为基本数据类型需要调用它的实例方法xValue();x代表基础数据类型的名称，这个过程比较繁琐，故从JDK1.5开始，JDK提供了自动装箱的特性，不再需要手动进行了。所谓装箱指：将基本数据类型转换为对应的封装器类型，拆箱指：将封装器类型转换为对应的基本数据类型。eg:
Integer a = 1;//装箱,底层实现：Integer a = Integer.valueOf(1);
int b = a; //拆箱,底层实现：int b = a.intValue();
eg:

public class PackageAndUnpackageDemo{
    public static void main(String[] args) {
        Integer a = 1;//装箱,底层实现：Integer a = Integer.valueOf(1);
        int b = a;    //拆箱,底层实现：int b = a.intValue();
    }
}

反编译结果

PackageAndUnpackageDemo.png

从图片中我们可以看到，装拆箱确实是这样实现的。
    此外，为了提高封装器的效率，Java将常用的数据缓存起来放到封装器对象数组里面，装箱的时候判断如果数据在缓存的范围内则从缓存里面取出对象，否则将new一个出来。
Integer相关的源码如下：

Integer_valueOf.png

我们可以看到，当数字的范围在low与high之间时，直接从cache对象数组中获取，否则就new一个对象，cache的源码如下：

Integer_cache.png

Integer的cache数组与其他的有些区别是，Integer可以自定义数组的上限，而其他封装器的cache是固定的。
封装器的缓存的大小以及他们对应的基础数据类型的范围见下表：

基本类型	封装器	字节数	最大值	最小值	缓存范围
byte	Byte	1byte	2^7 - 1	-2^7	-128~127
short	Short	2byte	2^15 - 1	-2^15	-128~127
char	Character	2byte	2^16 - 1	0	0~127
int	Integer	4byte	2^31 - 1	-2^31	-128~127
long	Long	8byte	2^63 - 1	-2^63	-128~127
float	Float	4byte	3.4e+38	1.4e-45	无缓存
double	Double	8byte	1.8e+308	4.9e-324	无缓存
boolean	Boolean	1byte/4byte/不明确	-	-	false、true

我们注意到Boolean与Byte全部被缓存了，boolean类型没有给出精确的定义，《Java虚拟机规范》给出了4个字节，和boolean数组1个字节的定义，具体还要看虚拟机实现是否按照规范来，所以1个字节、4个字节都是有可能的，这个在这里不做深究。
看到这里想必您现在应该能够理解下面的一些现象吧：

public class CacheDemo{
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        System.out.println(a == b);//true
        Integer c = 128;
        Integer d = 128;
        System.out.println(c == d);//false
        Integer e = -128;
        Integer f = -128;
        System.out.println(e == f);//true
        Integer g = -129;
        Integer h = -129;
        System.out.println(g == h);//false
    }
}

由于127与-128都在缓存数组缓存的范围内，所以他们是直接从缓存数组中取得的对象，故引用相同，而128与-129不在该范围内，所以是new出来的，故引用不相同。当然得到这个结果的前提条件是我们没有指定Integer缓存数组的上限，直接使用它的默认上限127。您可以通过-Djava.lang.Integer.IntegerCache.high=128 指定上限为128，那么运行结果就有所不同了。
java CacheDemo

true
false
true
false

java -Djava.lang.Integer.IntegerCache.high=128 CacheDemo

true
true
true
false

到这里需要提醒一下大家的是，“Java中对引用类型而言 == 比较的是引用，而equals()比较的是内容”这句话其实严格意义上来讲不准确。
我们不妨看一下对象之源Object中关于equals()的实现

public boolean equals(Object obj) {
    return (this == obj);
}

OK，Object的equals()方法默认还是使用了 “==”，所以要是自定义的对象没有Override该方法与hashCode()方法，那么比较的也是引用而不是内容了,当然Java的大部分类都重写了该方法，但是还有一些类如StringBuffer，StringBuilder没有重写该方法，这点需要注意。

注意事项

空指针异常

自动的装拆箱给我们带来了很大的方便，大部分情况下我们都将封装器与基础数据类型混为一谈了，但是二者之间毕竟还是存在着一些差别，在某些场景下要是不注意，自动装拆箱这个语法糖也会给我们带来一些意想不到的后果。
    由于引用类型的默认值是null,而不能将null赋值给基本数据类型，在拆箱的过程中可能会导致空指针异常，这个需要我们格外注意要加以判断：
如下面的情形：

import java.util.List;
import java.util.ArrayList;
public class NullPointInUnpackageDemo{
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>(3);
        list.add(0);
        list.add(1);
        list.add(null);
        for (int n:list){
            System.out.println("n="+n);
        }
    }
}

运行结果：

n=0
n=1
Exception in thread "main" java.lang.NullPointerException
    at NullPointInUnpackageDemo.main(NullPointInUnpackageDemo.java:10)

当然例子出现空指针异常的情况我们一眼就能够看出，但是实际开发过程可能由于疏忽或者不那么直接的拆箱行为，将会带来意想不到的错误，这是我们需要格外注意的。

封装器带来的模糊性问题

在方法的重载某些情形，封装器带来的使用可能会带来方法调用的模糊性问题，给我们带来一些意想不到的bug，比如下面的情形：

public class BugInOverloading{
    public static void test(Integer num){
        System.out.println("Integer num");
    }
    public static void test(long num){
        System.out.println("long num");
    }
    public static void main(String[] args) {
        test(1);
    }
}

您能够一眼看出会调用哪个方法吗？好吧，结果可能与您想象中的可能有点出入，运行结果是

long num

也就是说它居然没有调用test(Integer num)，反而直接向上转型为long 调用了test(long num)，这不很费解吗？对于该现象的解释是：Java为了向下兼容，保证程序的正确性，在方法重载时先不考虑自动装拆箱，而是遵循最精确匹配的原则，找最匹配的类型，由于没有int类型的方法可以调用，但是有long类型的方法，那么根据这个原则，int向上转型为long了，而不是自动装箱，这点需要注意,(ps:关于方法重载调用的问题可以参考博主另外的一篇文章 )额，时间不早了，就先这样吧，以上便是Java基本数据类型及其封装器的一些千丝万缕的纠葛。
圉于博主的水平，理解可能有所偏差，还望各位大佬不吝指正！