前言

Java 一种静态编程语言，所有变量和表达式是在编译时就确定的。同时，Java 又是一种强类型语言，所有的变量和表达式都有具体的类型，并且每种类型是严格定义的。在 Java 中共有8种基本类型数据，同时每种基本类型又有对应的包装类。

基本数据类型（默认值）	包装类（默认值）	取值范围
byte (0)	Byte (null)	-128～127
short (0)	Short (null)	-32768～32767
int (0)	Integer (null)	-231 ～ 2(31-1)
long (0)	Long (null)	-263 ~ 2(63-1)
float (0.0)	Float (null)	1.4E-45~3.4028235E38
double (0.0)	Double (null)	4.9E-324~1.7976931348623157E308
boolean (false)	Boolean (null)	true或false
char (为空)	Character (null)	0～65535

一、包装类型可以为null，而基本类型不可以

• 包装类型可以应用于POJO中（POJO专指只有setter/getter/toString的简单类，包括DO/DTO/BO/VO 等），而基本类型不行
• 和POJO类似的，还有传输对象DTO（接收前端传参）、视图对象VO（返回给前端的数据）、ENTITY（与数据库表中的字段含义完全对应，表的实体类）
• 为什么POJO的属性必须要用包装类型呢？
  • 《阿里巴巴Java开发手册》这样说明：数据库的查询结果可能是null，如果使用基本类型的话，因为要自动拆箱（将包装类型转为基本类型，比如说把Integer 对象转换成int值），就会抛出 NullPointerException 的异常。
• 案例：下面的代码可以编译通过，但是会抛出空指针异常（java.lang.NullPointerException）。int b = a 实际上是 int b = a.intValue()，由于 a 的引用值为 null ，在空对象上调用方法就会抛出 NullPointerException 异常。

  •     @Test
        public void a34() {
            Integer a = null;
            int b = a;
            System.out.println(b);
        }

二、包装类型可用于泛型，而基本类型不可以

        泛型不能使用基本类型，因为使用基本类型时会编译出错。

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

三、基本类型比包装类型更高效

        基本类型在栈中直接存储的具体数值，而包装类型则存储的是堆中的引用。

        很显然，相比较于基本类型而言，包装类型需要占用更多的内存空间（堆中占一块内存，栈中也占用一块内存）。假如没有基本类型的话，对于数值这类经常使用到的数据来说，每次都要通过new一个包装类型就显得非常笨重。

 四、两个包装类型得值可以相同，但却不相等

    @Test
    public void a31() {
        Integer integer = new Integer(10);
        Integer integer1 = new Integer(10);
        System.out.println(integer == integer1);        // false
        System.out.println(integer.equals(integer1));   // true
    }

• ==判断的是是否引用同一个对象（判断基本类型比较的是值，判断引用类型比较的是地址，包装类型就是基本数据类型得引用类型）
• 这里==比较的是变量（栈）内存中存放的对象的（堆）内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象
• 为什么 integer.equals(integer1) 的输出结果为true，是因为 equals 方法内部比较的是两个 int 值是否相等。源码如下：

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

 五、自动装箱和自动拆箱

既然有了基本类型和包装类型，肯定有些时候要在它们之间进行转换。把基本类型转换成包装类型的过程叫做装箱（boxing），反之，把包装类型转换成基本类型的过程叫做拆箱（unboxing）。

•  在 Java SE5 之前，开发人员要手动进行装拆箱，比如说：

        Integer a = new Integer(10);  // 手动装箱
        int i = a.intValue();       //  手动拆箱
        System.out.println(i);     //  10

• Java SE5 为了减少开发人员的工作，提供了自动装箱与自动拆箱的功能。

        Integer b = 10;     // 自动装箱
        int c = b;          // 自动拆箱
        System.out.println(c);  // 10

反编译过程如下：

        Integer d = Integer.valueOf(10);  // 自动装箱
        int e = d.intValue();             // 自动拆箱
        System.out.println(e);  // 10

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

1、下面看一道面试题：

// 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

• 第一段代码，基本类型和包装类型进行 == 比较，这时候 b 会自动拆箱，直接和 a 比较值，所以结果为 true
• 第二段代码，两个包装类型都被赋值为了100，这时候会自动装箱。在第四个标题的结论是：将 == 操作符应用于包装类型比较的时候，其结果很可能会和预期的不符。那结果是false？但这次的结果却是 true ，是不是摸不着头脑，有点晕晕的？
• 第三段代码，两个包装类型重新被赋值为了200，这时候仍然会进行自动装箱，结果是 true，这里跟第二段代码不同之处就是值不一样，结果就不一样，我们来看看源码：
  • 前面已经了解，自动装箱是通过  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 的影响？继续看源码：

    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() {}
    }

 大致看一下这段源码，-128 到 127 之间的数是从 IntegerCache 中获取，然后比较，所以第二段代码（100 在这个范围之内）的结果为 true，而第三段代码（200不在这个范围之内，所以 new 出来两个 Integer 对象）的结果是false。

• 总结一下：当需要进行自动装箱时，如果数字在 -128 至 127 之间时，会直接使用缓存中的对象，而不用重新创建一个对象。

六、下面看一个性能差异的代码

自动装拆箱是一个很好的功能，大大节省了我们开发人员的精力，但也会引发一些麻烦，比如下面这段代码，性能就很差。

    @Test
    public void a33() {
        long t1 = System.currentTimeMillis();
        Long sum = 0L;
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            sum += i;
        }
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);  // 6189   678
    }

• sum 由于被声明成了包装类型 Long 而不是基本类型 long，所以 sum += i 进行了大量的拆装箱操作（sum 先拆箱和 i 相加，然后再装箱赋值给 sum），导致这段代码运行完花费的时间足足有 6189 毫秒。如果把 sum 换成基本类型 long，时间就仅有 678 毫秒，完全不一个等量级啊。.

七、总结

1、为什么有基本类型还要有包装类型？

首先，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型 Collection 时就一定要使用包装类型而非基本类型），它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

另外，集合类（ArrayList，HashMap等）里面保存的必须是 Object 类型的对象，无法保存基本类型。

2、那只有包装类型不就可以了？

我们知道 Java 中，new 一个对象会存储在堆里，我们通过栈中的引用来使用这些对象。由于基本数据类型很常用，如果我们用 new 将其存储在堆里效率明显降低。

3、基本类型和包装类型的异同

• 在 Java 中，一切皆对象，但八大基本类型却不是对象。
• 声明方式的不同，基本类型无需通过 new 关键字来创建，而封装类型需 new 关键字。
• 存储方式及位置的不同，基本类型是直接把存储变量的值保存在栈中能高效的存取，封装类型需要通过引用指向实例，具体的实例保存在堆中。
• 初始值的不同，封装类型的初始值为 null，基本类型的初始值视具体的类型而定，比如 int 类型的初始值为 0，boolean 类型为 false。
• 使用方式的不同，比如与集合类合作使用时只能使用包装类型。
• 什么时候该用包装类，什么时候用基本类型，看基本的业务来定。这个字段允不允许 null 值，如果允许 null 值，则必需用封装类，否则值类型就可以了。用到比如泛型和反射调用函数，就需要用包装类。