Wrapper包装类
我们知道Java是一个面相对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型），它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。
另外，当需要往ArrayList，HashMap中放东西时，像int，double这种基本类型是放不进去的，因为容器都是装object的，这是就需要这些基本类型的包装器类了。
拆箱和装箱
先看一段代码：
public static void main(String args[]){
int a = 200;
//普通封装包装类型
Integer A1 = new Integer(a);
// 自动装箱
Integer A2 = a;
Integer B = new Integer(200);
//普通拆箱
int b1 = Integer.valueOf(B);
//自动拆箱
int b2 = B;
}
基本类型和包装类型的区别
①基本类型不使用new关键字，他是个常量。而包装类型需要使用new关键字来在堆中分配存储空间，是个对象；
②基本类型是直接将变量值存储在栈中（常量在栈中），而包装类型是将对象放在堆中（对象在堆中），然后通过引用来使用；
③基本类型的初始值如int为0，boolean为false，而包装类型的初始值为null；
④基本类型使用比较广泛，包装类型一般用在ArrayList，HashMap中。
面试中的常见坑
1.这段代码的输出
public static void main(String args[]){
int a1 = 300;
int a2 = 300;
Integer A1 = new Integer(300);
Integer A2 = new Integer(300);
Integer C1 = 3;
Integer D1 = 3;
Integer C2 = 300;
Integer D2 = 300;
System.out.println(a1 == a2);//true
System.out.println(A1 == A2);//false
System.out.println(C1 == D1);//true
System.out.println(C2 == D2);//false
System.out.println(a1 == A1);//true
System.out.println(A1 == C2);//false
System.out.println(a1 == C2);//true
}
下面我们逐一分析结果
①System.out.println(a1 == a2);//true
因为都是int型，是基本数据类型，所以==在比较基本数据类型的时候，只比较数值。
②System.out.println(A1 == A2);//false
因为A1，A2都是new的对象，所以都是在堆中开辟了新的空间的，==在比较对象的时候，比较的是引用中存储的地址，所以是false。
③System.out.println(C1 == D1);//true
System.out.println(C2 == D2);//false
这两个合起来看，这是咋地啦？怎么换个数结果就不一样了？
下面这段代码是Integer的valueOf方法的具体实现：
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
return IntegerCache.cache[i + 128];
else
return new Integer(i);
}
而其中IntegerCache类的实现为：
private static class IntegerCache {
static final int high;
static final Integer cache[];
static {
final int low = -128;
// high value may be configured by property
int h = 127;
if (integerCacheHighPropValue != null) {
// Use Long.decode here to avoid invoking methods that
// require Integer's autoboxing cache to be initialized
int i = Long.decode(integerCacheHighPropValue).intValue();
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - -low);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}
从上面2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。
④ System.out.println(a1 == A1);//true
System.out.println(A1 == C2);//false
System.out.println(a1 == C2);//true
先分别说一下a1是基本数据类型，A1是普通的装箱的对象，C2是自动装箱的对象。
a1==A1：是基本数据类型==普通封装的对象，这个时候包装类对象会自动拆箱，然后比较数值。
A1 == C2: 自动装箱也是new了个对象，所以他俩内存中地址是不一样的。
a1 == C2：和a1==A1同理。
2.下面代码的结果
public static void main(String args[]){
double a1 = 100.0;
double a2 = 100.0;
Double B1 = 100.0;
Double B2 = 100.0;
Double C1 = 200.0;
Double C2 = 200.0;
System.out.println(a1 == a2);//true
System.out.println(a1 == B1);//true
System.out.println(B1 == B2);//false
System.out.println(C1 == C2);//false
}
①前面两个
System.out.println(a1 == a2);//true
System.out.println(a1 == B1);//true
老生常谈了哈，就是基本数据类型之间==比较值，封装类型和基本数据类型==时，封装类型自动拆箱了，所以都是true！
②后面两个
System.out.println(B1 == B2);//false
System.out.println(C1 == C2);//false
怎么和int不一样了，没有缓存了吗？是的，没有！
public static Double valueOf(double d) {
return new Double(d);
}
源码里直接，给new了个对象，这个糟老头子坏得很！23333
注意：
Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
Double、Float的valueOf方法的实现是类似的。
3.下面这段代码的结果
public static void main(String[] args) {
Boolean a1 = false;
Boolean a2 = false;
Boolean b1 = true;
Boolean b2 = true;
System.out.println(a1==a2);//true
System.out.println(b1==b2);//true
}
为啥都是true呢，因为源码中true和false都被定义了静态属性。
public static final Boolean TRUE = new Boolean(true);
/**
* The Boolean object corresponding to the primitive
* value false.
*/
public static final Boolean FALSE = new Boolean(false);
4.下面代码的输出
public static void main(String args[]){
Integer a = 10;
Integer b = 20;
Integer c = 30;
Integer d = 30;
Long g = 30L;
Long h = 20L;
System.out.println(c==(a+b));//true
System.out.println(c.equals(a+b));//true
System.out.println(g==(a+b));//true
System.out.println(g.equals(a+b));//false
System.out.println(g.equals(a+h));//true
}
在分析上面代码结果前，要明白四件事：
①当 "=="运算符的两个操作数都是 包装器类型的引用，则是比较指向的是否是同一个对象，就是要看引用；
②当 "=="运算符的两个操作数其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。
③对于包装器类型，equals方法并不会进行类型转换。euqals会先比较数据类型，再比较值！
④两个不同的数据类型相加，结果是高的那个数据类型，比如int+float，返回的是float。