Java 基本类型和包装器类型 自动装箱和拆箱

一、基本数据类型和包装器类型

1.关系：基本数据类型变量存储于堆栈中，可以直接存储“值”，而基本数据类型所具有的包装器类，可以在堆中创建一个非基本对象，用来表示对应的基本类型。
2.对照表：

基本类型	大小	范围	包装器类型
boolean	—	—	Boolean
char	16-bit	Unicode 0 ~ Unicode $2^{16}$-1	Character
byte	8bits	-128 ~ +127	Boolean
short	16bits	-$2^{15}$ ~ +$2^{15}$-1	Short
int	32bits	-$2^{31}$ ~ +$2^{31}$-1	Integer
long	64bits	-$2^{63}$ ~ +$2^{63}$-1	Long
float	32bits	IEEE754	Float
double	64bits	IEE754	Double

boolean类型所占存储空间的大小没有明确指定，仅定义为能够取字面值true和false

3.用法：

char c = 'x';
Character ch = new Character('x');

二、关于自动装箱和拆箱

1.自动装箱

1）将基本数据类型直接赋值给包装器类型会触发自动装箱：

Integer integer = 9;

2） 原理分析：

自动装箱底层调用了Integer.valueOf(9)，valueOf源码：

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

再看一下Integer的构造器：

private final int value;

public Integer(int value) {
    	this.value = value;
}

public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
    }

它里面定义了一个value变量，创建一个Integer对象，就会给这个变量初始化。第二个传入的是一个String变量，它会先把它转换成一个int值，然后进行初始化。

3）IntegerCache类：
上面涉及了IntegerCache，这是Integer构造的一个缓存器，它事先把范围在-128~127之间的整数存储到一个static final Integer cache[]数组中，当我们想要初始化一个在这之间的数时，就会直接从这个缓存数组中拿，而不会重新构造一个Integer对象
4）总结：
自动装箱调用底层的valueOf(int i)方法，当整数范围在（-128，127）时，会从缓存数组中直接取出构建好的Integer对象，而在这个范围外的整数，则会调用构造方法，new一个Integer对象

2.自动拆箱

1）将包装器类型直接赋值给基本类型变量：

Integer integer = new Integer(9);
int i = integer;//自动拆箱

2）原理分析：
自动拆箱底层调用了integer.intValue()，直接返回了int类型的value值

public int intValue() {
        return value;
    }

三、自动装箱过程中的对象创建问题

1）前面已经提到了，对于Integer类型的自动装箱，当我们要赋值的整数在（-128，127）之间时，不会创建新的Integer对象：

public static void main(String args[]) throws UnsupportedEncodingException {
        Integer i1 = 1;
        Integer i2 = 1;
        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i1==i2);
        System.out.println(i3==i4);

    }/**output
    true
	false
	**/

2）不仅是Integer类，Character、Byte、Short、Long这几个包装类的valueOf方法实现原理类似，都会有缓存器
3）对于Double、Float，它们在-128~127之间的数是无限的，因此没有缓存器
4）对于Boolean，它在一开始就定义了并创建好了两个Boolean类型对象，因此后面也不会再新建Boolean对象：

private final boolean value;
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);

四、包装类和基本类型的混合比较

1.==比较

1）不含算术运算符：

int i = 9;
Integer integer = 9;
System.out.println(i==integer);
/**output
true
**/

以上情况说明了包装类在和基本类型比较时，包装类会先自动拆箱（上述情况实际是先装箱，比较的时候再拆箱）

2）包含算术运算符

int i = 9;
Integer integer = 9;
Long num = 18L;
System.out.println(i+integer);
System.out.println(num==(i+integer));
/**output
18
true
**/

当封装类参与算术运算时，会将封装类进行拆箱，转化为基础数据类型进行运算

2.equals比较

1）equals方法只有包装类有，源码如下:

public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

可见传入的是个Object类型，先判断obj是不是Integer类的实例，如果是，再判断对象内的value值是否一致

2）情况一：

int i = 9;
Integer integer = 9;
System.out.println(integer.equals(i));
/**output
true
**/

传入的int类型要转化为Object类型首先会自动装箱为包装类对象，然后进行对象里value值的比较
3）情况二：

int i = 9;
Integer integer = 9;
Long num = 9L;
System.out.println(num.equals(integer));
System.out.println(num.equals(i));
/**output
false
false
**/

第一个false为Integer与Long类型不同
第二个false为int先装箱为Integer，Integer与Long类型不同

五、补充

1.boolean类型到底占多少字节

参考博文：https://blog.csdn.net/YuanMxy/article/details/74170745

2.装箱拆箱

1）装箱操作会创建对象，频繁的装箱操作会消耗许多内存，影响性能，所以可以避免装箱的时候应该尽量避免。
2）误区：

Integer integer = null;
int i = integer;

可以通过编译，但运行时会报空指针异常，因为integer为null，那么就不能自动拆箱调用integer.intValue()，一个空对象不可能调用方法。