在 Java 中，每个都对应了一个包装类型，比如：int 的包装类型是 Integer，double 的包装类型是 Double…那么，基本数据类型和包装类型有什么区别呢？

大概有以下几点区别：

成员变量的包装类型不赋值就是 null，而基本数据类型有其默认值并且不是 null。
包装类型可以用于泛型，而基本数据类型不可以用于泛型。
基本数据类型的局部变量（在方法中声明的变量）存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（在类中声明的变量）存放在 Java 虚拟机的堆中；而包装类型属于对象类型，对象实例都存放在堆中。
相比于对象类型，基本数据类型占用的空间非常小。
两个包装类型的值可以相同，但是却不相等。

注意：基本数据类型存放在栈中是一个常见的误区！基本数据类型的局部变量（在方法中声明的变量）存放在方法栈中；基本数据类型的成员变量（在类中声明的变量，也叫全局变量）存放在堆中。

我们主要是从基本数据类型和包装类型的数据转换中来区别拆箱和装箱：

拆箱：将包装类型转为基本数据类型；
装箱：将基本数据类型转为包装类型。

1. 包装类型可以为 null，而基本数据类型不可以

这一点区别使得包装类型可以应用于 POJO（Plain Ordinary Java Object）中，POJO 就是简单无规则的 Java 对象，只有字段及其对应的 setter 和 getter 方法：

class Person {
	private Integer age;
	private String name;

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

同样地，还有 DTO（Data Transfer Object）数据传输对象，泛指用于 View 层与 Service 层之间的数据传输对象；VO（View Object）视图对象，用于把向页面上展示的数据封装起来；PO（Persistant Object）持久化对象，类似于与数据库中的表映射的 Java 对象。

为什么 POJO 中的字段必须要使用包装类型呢？

《阿里巴巴 Java 开发手册》上有详细的说明：
数据库查询的结果可能是 null，如果使用基本类型的话，因为要自动拆箱，就会抛出 NullPointerException 异常（null 值拆箱异常）。

2. 包装类型可以用于泛型，而基本数据类型不可以

List<int> list = new ArrayList<>(); // 提示 Syntax error, insert "Dimensions" to complete ReferenceType
List<Integer> list = new ArrayList<>();

这里编译器会提示错误：
Java 中的拆箱和装箱-小白菜博客
这是为什么呢？

因为在编译时会进行类型擦除，最后只保留原始类型，而原始类型只能是 Object 类及其子类（不包括基本数据类型）。

3. 基本数据类型比包装类型更高效

作为局部变量时，基本数据类型在栈中直接存储的是具体的数值，而包装类型则存储的是堆中的引用：
Java 中的拆箱和装箱-小白菜博客
显然，相比较而言，包装类型需要占用更多的内存空间，因为它不仅需要存储对象，还要存储对象的引用。也就是说，如果没有基本数据类型的话，对于数值这种经常使用到的数据来说，每次都要通过 new 一个包装类型就显得非常笨重了。

4. 两个包装类型的值可以相同，但是却不相等

/**
 * 拆箱和装箱
 * 1. 包装类型（可以应用于pojo）可以为null，基本类型不可以
 * 2. 包装类型可以用于泛型，基本类型不可以
 * 3. 基本类型比包装类型更高效
 * 4. 两个包装类型的值可以相同，但是不相等
 *
 * @author qiaohaojie
 * @date 2023/3/4  18:00
 */
public class PackAndUnPacking {
    public static void main(String[] args) {
        Integer a = new Integer(10);
        Integer b = new Integer(10);
        System.out.println(a == b); // false
        System.out.println(a.equals(b)); // true
    }
}

两个包装类型在使用 “==” 进行判断的时候，判断的是其指向的地址是否相等，因为是两个对象，所以地址是不同的。

而 a.equals(b) 的输出结果是 true，是因为 equals() 方法内部比较的是两个 int 值是否相等：

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

在 equals() 方法的源码中，((Integer)obj).intValue() 就是用来自动拆箱的。

既然有基本数据类型也有包装类型，那么在使用的时候要在它们之间进行转换：

把基本数据类型转换成包装类型的过程叫做装箱；
把包装类型转换成基本数据类型的过程叫做拆箱。

在 JDK 1.5 之前，我们要进行手动装箱和拆箱：

Integer a = new Integer(10); // 手动装箱
int b = chenmo.intValue();  // 手动拆箱

JDK 1.5 以后，为了减少开发人员的工作量，提供了自动装箱与自动拆箱的功能：

Integer a  = 10; // 自动装箱
int b = a; // 自动拆箱

看一下反编译后的代码：

Integer a = Integer.valueOf(10);
int b = chenmo.intValue();

也就是说，自动装箱是通过 Integer.valueOf() 完成的；自动拆箱是通过 Integer.valueOf() 完成的。

来看一下下面的例子：

// 1. 基本类型和包装类型
int a = 100;
Integer b = 100;
System.out.println(a == b); // true

// 2. 两个包装类型
Integer c = 100;
Integer d = 100;
System.out.println(c == d); // true

// 3. 给包装类型重新赋值
c = 200;
d = 200;
System.out.println(c == d); // false

第一个结果是 true，基本类型在与包装类型进行 == 比较的时候，包装类型会自动拆箱，也就以为着两者比较的是值，值都是100，所以结果为 true.
第二个结果是 true，两个包装类型的被赋值为 100，这个时候会进行自动装箱，在上面的例子中我们知道，自动装箱是通过 Integer.valueOf() 方法来完成的，我们来扒一下 Integer.valueOf() 方法的源码：
```
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
```
这里面使用了一个静态内部类 IntegerCache，在中介绍了这个静态内部类的作用及执行步骤。

其实也就需要记住一点：当需要自动装箱时，在 -128~127 之间的数字会从 IntegerCache 中取，而不是重新创建一个对象。
第三个结果是 false，两个包装类型被重新赋值为 200，仍然会进行自动装箱，但是 200 不在这个缓存中，要创建两个对象，所以是 false。