int与Integer的区别引入拆箱装箱。

由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 ())));