java中int与Integer用==比较详解

前言：

    越是简单的东西，我们往往越是没有去把它明白，但我们大部分时间又常常在用，就像我们今天说的int与Integer的使用，我们程序员基本天天都在用，但是我今天没用详细弄清楚之前我也是不清楚，我们来看看这两个在用==号比较给我们带来的疑问。

先看看下面的代码，看看我们是否都会

    @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

看看结果跟我们自己做的是不是都一样。

        下面我们就来详细解释一下，为什么是上面的结果。（下面的序号就是对应的是上面的答案序号）

          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对象时，使用它==来比较值是很诱人的，因为这是您将使用的int值。在某些情况下，这似乎有效：

Integer int1_1 = Integer.valueOf("1");
Integer int1_2 = Integer.valueOf(1);
System.out.println("int1_1 == int1_2: " + (int1_1 == int1_2));          // true
System.out.println("int1_1 equals int1_2: " + int1_1.equals(int1_2));   // true

在这里我们创建了两个Integer具有值的对象，1并比较它们（在这种情况下，我们创建了一个来自一个String，一个来自一个int文字，还有其他的选择）。此外，我们观察到两种比较方法（==和equals）都产生true。

当我们选择不同的值时，这种行为会改变：

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对象。

Integer valueOf(String s)的源码:

我们平时用到Integer.parseInt("123");其实默认是调用了int i =Integer.parseInt("123"，10);
其中10代表的默认是10进制的，转换的过程可以看成：

 i=  1*10*10+2*10+3  
若是  
               int i = Integer.parseInt("123"，16);  
即可以看成：  
               i  = 1*16*16+2*16+3  

根据：Character.MIN_RADIX=2和Character.MAX_RADIX=36 则，parseInt(String s, int radix)参数中
radix的范围是在2~36之间，超出范围会抛异常。其中s的长度也不能超出7，否则也会抛异常。

那么 Integer.valueOf("1000")应该相当于:

Integer.valueOf("1000",10);
Integer.valueOf("1000",10)
1*10^3 + 0*10^2 + 0*10^1 + 0*10^0 = 1000

返回1000

那就相当于:

Integer int2_1 = new Integer(1000);
Integer int2_2 = new Integer(1000);

 equals用来比较的是两个对象的内容是否相等,所以这里结果为true
如果是==, == 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。用==比较的话就是false