由int与Integer的区别引入拆箱装箱。
Java有primitive Type和Object，然后primitive type 有啥，Object有啥
primitive Type：原始类型一共有8种
原始类型一共有8种，它们分别是char,boolean,byte,short,int,long,float,double。在Java API中，有它们对应的包装类，分别是(首字母大写)Character,Boolean,Byte,Short,Integer,Long,Float,Double(char,int的变化稍微大点)。
JAVA JVM对于不同的原始类型会分配不同的存储空间，具体分配如下：
byte : 1个字节 8位最大值: 127 (有符号)
short : 2个字节 16位 32767
int : 4个字节 32位 2147483647
long: 8个字节 64位 9223372036854775807
float: 4个字节 32位 3.4028235E38
double:8个字节 64位 1.7976931348623157E308
拆装概念的参考是对象，对象就是箱，由primitive Type变成Object类型就叫装箱，反之交拆箱。
public static void main(String[] args) {
Integer i = 10;//直接声明Integer i = 10，会自动装箱变为Integer i = Integer.valueOf(10)
Integer j = 10;
System.out.println(i == j);//比较i、j所指的对象是否是同一个对象，，堆内存中只有一个10对象结果为true
//结果为true,及i、j指向同一个对象。
/* i >= -128 并且 i <= 127 的时候，第一次声明会将 i 的值放入缓存中，第二次直接取缓存里面的数据，而
* 不是重新创建一个Ingeter 对象。那么第一个打印结果因为 i = 10 在缓存表示范围内，所以为 true。
128是不在-128到127之间的，所以第一次创建对象的时候没有缓存，第二次创建了一个新的Integer对象。故打印结果为false*/
Integer a = 128;
Integer b = 128;
System.out.println(a == b);//a、b分别指向两个128对象，堆内存中有两个128对象
int k = 10;
System.out.println(k == i);//由于k是int型，所以Integer i 会自动拆箱为 i.intValue()进行比较，结果为true
int kk = 128;
System.out.println(kk == a);//Integer a 自动拆箱为 i.intValue()进行比较结果为true
/*
这个虽然值为10，但是我们都是通过 new 关键字来创建的两个对象，
是不存在缓存的概念的。两个用new关键字创建的对象用 == 进行比较，结果当然为 false。*/
Integer m = new Integer(10);
Integer n = new Integer(10);
System.out.println(m == n);//比较的是m和n所指对象的内存地址，内存地址不同则代表指向不同的对象，堆内存中new两个10对象结果为false
System.out.println(m.equals(n));//比较m和n指向的对象的值是否相同。结果为true
}
/*反编译代码
* Integer i = Integer.valueOf(10);
Integer j = Integer.valueOf(10);
System.out.println(i == j);
Integer a = Integer.valueOf(128);
Integer b = Integer.valueOf(128);
System.out.println(a == b);
int k = 10;
System.out.println(k == i.intValue());
int kk = 128;
System.out.println(kk == a.intValue());
Integer m = new Integer(10);
Integer n = new Integer(10);
System.out.println(m == n);*/
——————————————————————————————
public static void main(String[] args) {
Integer a = 1;//自动装箱，a存放对象1的内存地址
Integer b = 2;
Integer c = 3;//自动装箱，c、d都存放对象3的内存地址，只有一个3对象
Integer d = 3;
Integer e = 321;//自动装箱，e存放321的内存地址
Integer f = 321;//自动装箱，f存放321的内存地址,两个321对象
Long g = 3L;//自动装箱，g存放3L的内存地址
Long h = 2L;//自动装箱，h存放2L的内存地址
System.out.println(c == d);//比较c、d的值，同一个内存地址，结果为true
System.out.println(e == f);//比较e、f的值，两个内存地址，结果为false
System.out.println(c == (a + b));//自动拆箱，1和2相加的值与3比较，结果为true。
System.out.println(c.equals((a+b)));//先自动拆箱，1和2相加得到3，然后自动装箱，让一个变量指向相加得到的3对象。然后比较相加得到的3对象与c指向的3对象，数值是否相等，结果为true。
System.out.println(g == (a+b));//自动拆箱，1和2相加得到3，然后强制转换成3L。最后把Long g也拆箱得到g=3L，比较结果为true
System.out.println(g.equals(a+b));//首先自动拆箱，1和2相加得到3，然后自动装箱为Integer ，让一个变量指向相加得到的3对象。
// 然后比较相加得到的3对象与g指向的3L对象，数值是否相等,，由于equals无法进行类型转换，所以是结果为false。
System.out.println(g.equals(a+h));//首先自动拆箱，1和2L相加得到3L，然后自动装箱为Long ，让一个变量指向相加得到的3L对象。
// 然后比较相加得到的3L对象与g指向的3L对象，数值是否相等,，，所以是结果为true。
}
/*反编译代码
* Integer a = Integer.valueof (1);
Integer b = Integer.valueOf (2);
Integer c = Integer.valueof (3);
Integer d = Integer.valueof (3);
Integer e = Integer. valueof (321);
Integer f = Integer.valueof (321);
Long g- Long.valueOf (3L);
Long h -Long.valueof (2L);
System.out.println(c-d);
System.out.printin(e -f);
System.out.printin (c.intValue () a.intValue() + b.intValue ());
System.out.println (c. equals (Integer.valueOf (a.intValue () + b.intvalue ())));
System.out.println(g.longValue () (1ong) (a.intValue () + b.intvalue()));
System.out.println (g.equals (Integer.valueOf (a.intValue() + b.intValue()));
System.out.println (g.equals (Long.valueof ((1ong)a.intValue () + h.longValue ())));