拆箱装箱
举个例子
@Test
public void testEquals() {
int int1 = 12;
int int2 = 12;
Integer integer1 = new Integer(12);
Integer integer2 = new Integer(12);
Integer integer3 = new Integer(127);
Integer a1 = 127; //或许写成Integer a1 = Integer.valueOf(127);
Integer a2 = 127;//或许写成Integer a2 = Integer.valueOf(127);
Integer a = 128;
Integer b = 128;
System.out.println("int1 == int2 -> " + (int1 == int2));
System.out.println("int1 == integer1 -> " + (int1 == integer1));
System.out.println("integer1 == integer2 -> " + (integer1 == integer2));
System.out.println("integer3 == a1 -> " + (integer3 == a1));
System.out.println("a1 == a2 -> " + (a1 == a2));
System.out.println("a == b -> " + (a == b));
}
答案是：
1、int1 == int2 -> true
2、int1 == integer1 -> true
3、integer1 == integer2 -> false
4、integer3 == a1 -> false
5、a1 == a2 -> true
6、a == b -> false
看看成果跟咱们自己做的是不是都相同。A8站源码交易平台
下面咱们就来详细解释一下，为什么是上面的成果。（下面的序号便是对应的是上面的答案序号）
1、int1 == int2 为true，这个我就讲了，这个都知道
2、int1 == integer1，Integer是int的封装类，当Integer与int进行==比较时，Integer就会拆箱成一个int类型，所以仍是相当于两个int类型进行比较，这儿的Integer,不管是直接赋值，仍是new创立的目标，只需跟int比较就会拆箱为int类型，所以便是持平的。
3、integer1 == integer2 -> false，这是两个都是目标类型，并且不会进行拆箱比较，所以不等
4、integer3 == a1 -> false , integer3是一个目标类型，而a1是一个常量它们寄存内存的方位不相同，所以也不等，详细存在内存的方位看以看文章
5、6 看起来是一模相同的为什么一个是true，一个是false？这是由于Integer作为常量时，关于-128到127之间的数，会进行缓存，也便是说int a1 = 127时,在规模之内，这个时分就寄存在缓存中，当再创立a2时，java发现缓存中存在127这个数了，就直接取出来赋值给a2，所以a1 == a2的。当超越规模便是new Integer()来new一个目标了，所以a、b都是new Integer(128)出来的变量，所以它们不等。
依据以上总结：
①、无论如何，Integer与new Integer不会持平。不会阅历拆箱进程，由于它们寄存内存的方位不相同。（要看详细方位，能够看看这篇文章：点击翻开链接）
②、两个都对错new出来的Integer，假如数在-128到127之间，则是true,否则为false。
③、两个都是new出来的,则为false。
④、int和integer(new或非new)比较，都为true，由于会把Integer主动拆箱为int，其实便是相当于两个int类型比较。
行为差异
当咱们挑选不同的值时，这种行为会改动：
Integer int2_1 = Integer.valueOf("1000");
Integer int2_2 = Integer.valueOf(1000);
System.out.println("int2_1 == int2_2: " + (int2_1 == int2_2)); // false
System.out.println("int2_1 equals int2_2: " + int2_1.equals(int2_2)); // true
在这种状况下，只要比较equals才干得到正确的成果。
这种行为差异的原因是JVM保护Integer规模为-128到127 的目标的缓存（能够运用体系特点“java.lang.Integer.IntegerCache.high”
或JVM来掩盖上限值参数“-XX：AutoBoxCacheMax = size”）。关于此规模内的值，Integer.valueOf()将回来缓存的值，而不是创立一个新的值。
因而，在第一个示例中，Integer.valueOf(1)并且Integer.valueOf(“1”)调用回来相同的缓存Integer实例。相比之下，在第二个示例中Integer.valueOf(1000)，Integer.valueOf(“1000”)创立并回来了新Integer目标。
==参阅类型的运算符测验参阅持平（即同一目标）。因而，在第一个比如中int1_1 == int2_1是true由于引证是相同的
。第二个比如int2_1 == int2_2是false，由于引证是不同的。A8站源码交易平台
Integer的缓存
原因就在Integer的办法 valueOf
咱们来看这个办法的源码：字节码里调用的便是这个办法：
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
return IntegerCache.cache[i + 128];
else
return new Integer(i);
}
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() {}
}
Integer里弄了一个缓存，关于在 -128—127 之间的数值，会直接运用该缓存里的目标
也便是说 Integer c = 3 或许 Integer c = Integer.valueOf(3) ，终究 c 得到的是Integer里的缓存目标
同理，d也是获得该相同目标因而 进行 c == d 比较时，c和d引证的是同一个目标，因而就true
而关于321，现已超出缓存规模了，因而 valueOf 办法会生成一个新的Integer目标因而e和f就引证不同 的目标了，进行==比较，当然就false了
别的，对Integer的缓存，咱们在日常开发时，关于小的整型值应该充分利用Integer的缓存目标省去过多的目标创立，收回的操作，这样会极大的进步程序功能A8站源码交易平台
Integer妙用与圈套
考虑下面的小程序，你以为会输出为什么成果？
public class Test {
public static void main(String[] args) {
Integer n1 = 123;
Integer n2 = 123;
Integer n3 = 128;
Integer n4 = 128;
System.out.println(n1 == n2);
System.out.println(n3 == n4);
}
}
答案如下，请挑选打开：
true
fase
是否和你料想的共同？
咱们知道==比较的是目标的引证，那这儿为什么会这出这种状况呢？
原理
首要这是JDK在1.5版别中增加的一项新特性，把-128~127的数字缓存起来了，用于提高功能和节约内存。所以这个规模内的主动装箱（相当于调用valueOf(int i)办法）的数字都会从缓存中获取，回来同一个数字，所以现在你了解为什么了吧。一起这也会给咱们开发带来料想不到的圈套，直得留意！！A8站源码交易平台
而咱们经过new Integer(1)这样就不会从缓存中获取，咱们能够自行测验。
咱们来翻看下jdk中Integer的源码，下面是IntegerCache的源码，把从-128~high放在缓存中
下面是valueOf的源码，先从缓存中获取，获取不到再new一个回来。
从源码里边咱们能够看到最小鸿沟是-128，最大鸿沟能够经过-XX:AutoBoxCacheMax进行装备，但也不会大于Integer.MAX_VALUE最大值。
也便是说。该代码表明valueOf的山人加包是有规模的只能加包-128~127，超越这个规模将用new Interger的办法。因而将代码中的123改为1000，两个输出将都是false，并且所用的办法也相同都是在堆中调用一个地址用来贮存值，Interger类型的变量，贮存地址。
Integer在办法中的参数传递、回来值
（1）JAVA里除了8种根本类型传参数是值传递，其他的类目标传参数都是引证传递。
（2）Integer作为参数传递时引证传递。
（3）Integer作为参数传入办法，假如不设置回来值，Inerger的值就不会改动，原因：Integer每次赋值/改动都是被赋予新的目标，当Integer作为引证传入后，接纳的形参会被赋值成其他的引证，由于Integer里边的value是final类型的Int。
举个例子：
public class test{
public void add3(Integer i){
System.out.println("i赋值前的地址:"+System.identityHashCode(i));
i=3;
System.out.println("i赋值后的地址:"+System.identityHashCode(i));
}
@Test
public void test(){
Integer a=5;
System.out.println("a赋值前的地址:"+System.identityHashCode(a));
add3(a);
System.out.println("a赋值后的地址:"+System.identityHashCode(a));
a=10;
System.out.println("a修正值后的地址:"+System.identityHashCode(a));
System.out.println(a);
}
}
输出成果是：
a赋值前的地址:352359770
i赋值前的地址:352359770
i赋值后的地址:243745864
a赋值后的地址:352359770
a修正值后的地址:699780352
源码分析
在Integer源码中，int值是final润饰的，不能够改动
class Integer{
final int value; //一旦赋值，就不能改动。
}
