基本类型和包装类型的区别

1.基本类型有初始值，而包装类型的默认值是null

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	‘/u0000’(空)
boolean	false

2.包装类型可以为 null，而基本类型不可以

在第一点我们说了，基本类型有初始值，而包装类型的默认值是null。而这也是为什么包装类型可以应用于 POJO 中，而基本类型则不行。
在《阿里巴巴 Java 开发手册》中写到：

【强制】所有的POJO类属性必须使用包装数据类型。
正例：数据库的查询结果可能是null，因为自动拆箱，用基本数据类型接收有NPE（NullPointerException）风险。

3.存储位置有所区别

如果一个基本类型是成员变量就存储在堆内存里，如果是局部变量就存储在栈内存里；而包装类型则存储的是堆中的引用

4.包装类型可用于泛型，而基本类型不可以

如果我们这么写
List<int> a = new ArrayList<>();
编译器会报错：Type argument cannot be of primitive type(类型参数不能为基本类型)
这是为什么呢？因为泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除，最后只保留原始类型，而原始类型只能是 Object 类及其子类。
这里有一道经典的测试题：

List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
System.out.println(a.getClass() == b.getClass());

上述代码输出的结果为 true ，就是因为 List和 List在 jvm 中的 Class 都是 List.class。

5.在使用“==”进行判断的时候的不同

我们来看一个例子：

Integer a = new Integer(1);
Integer b = new Integer(1);
System.out.println(a == b); // false
System.out.println(a.equals(b )); // true

包装类型是对象，拥有方法和字段，对象的调用都是通过引用对象的地址，因此在使用 == 进行判断的时候，判断的是其指向的地址是否相等，若想判断它们的内容是否相等，需要使用equals()方法。而基本类型使用 == 直接判断其值是否相等。

6. 自动装箱和自动拆箱

把基本类型转换成包装类型的过程叫做装箱（boxing）。反之，把包装类型转换成基本类型的过程叫做拆箱（unboxing）。

1）基本类型和包装类型进行 == 比较，包装类型会自动拆箱，直接和基本类型比较值

int a = 9;
Integer b = 9;
System.out.println(a == b);

上述代码的结果为 true。

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

这个知识我之前从未听闻，正是在写这篇文章的时候查看相关技术博客才了解到的，又学到了新知识！
我们先来看这么一段代码：

Integer A = 199;  
int a = A;  

执行第一句代码的时候，系统为我们执行了：
Integer A = Integer.valueOf(199);
执行第二句代码的时候，系统为我们执行了：
int a = A.intValue();

也就是说，自动装箱是通过 Integer.valueOf() 完成的；自动拆箱是通过 Integer.intValue() 完成的。理解了原理之后，我们开始进入正题：

Integer a = 100;
Integer b = 100;
System.out.println(a == b);

上述代码的两个包装类型被赋值100后，都会进行自动装箱，那么 == 的结果是什么呢？答案是 true。
那么下面的输出结果是什么呢？

Integer a = 199;
Integer b = 199;
System.out.println(a == b);

答案是false。

同样都是包装类型的赋值，比较结果却不一样，这是怎么回事呢？？？之前我们已经知道了，自动装箱是通过 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 =
                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类中有一个静态内部类IntegerCache，在IntegerCache类中有一个Integer数组，用以缓存当数值范围为-128~127时的Integer对象。

所以一开始的代码Integer a = 100;Integer b = 100;System.out.println(a == b);的结果是 true，因为100 在-128~127范围之内，直接从缓存池中拿的。
而Integer a = 199;Integer b = 199;System.out.println(a == b);的结果是 false，因为199 不在这个范围之内，所以 new 出来了两个 Integer 对象。既然是new出来的，那就会在堆空间中产生不同的对象，不同的对象在进行 ==比较的时候，比较的是内存中的地址，不同对象的内存地址肯定不一样，所以返回false。

但是，我们再看一段代码

Integer a = 9999;
Integer b = 9999;
System.out.println(a + 1 == b + 1);

上述代码的运行结果是true，这是因为这2个包装类型的Integer在运算时会自动拆箱，变成2个基本数据类型的比较，相当于在判断

a.intValue() + 1 == b.intValue() + 1

而两个基本数据类型比较时只看数值大小，故结果为true