java对象相等问题

我不是女神ヾ 2022-05-21 01:38 133阅读 0赞

public class TestA {
    	private Integer a;
    	public Integer getA() {
    		return a;
    	}
    	public void setA(Integer a) {
    		this.a = a;
    	}
    }
    public class Test {
    	public static void main(String[] args) {
    		TestA a = new TestA();
    		a.setA(1);
    		TestA aa = a;
    		a.setA(3);
    		System.out.println(aa==a);
    		System.out.println(aa.getA());
    	}
    }

输出结果是true和3，这理解起来很简单，java中对象直接"="赋值其实就是将引用传给对方，让他也指向同一个内存地址。  
所以如果a改变了里面属性的值，那这个地址存储的内容就变了，当aa去拿的时候就是变了之后的，因为两个指向依然同一个地址，  
所以aa==a是true的。  
但如果这么来：

TestA a = new TestA();
    		a.setA(1);
    		TestA aa = a;
      a = new TestA();
    		a.setA(3);
    		System.out.println(aa==a);
    		System.out.println(aa.getA());

那输出就是false和1了，因为a又重新new了一个对象，他引用的地址已经变了，就和aa一点关系都没有了！

以上我们都知道，但对于包装类却看似不一样：

public class Test {
    	public static void main(String[] args) {
    		Integer b = new Integer(5);
    		Integer c = b;
    		System.out.println(b==c);
    		b = b+1;
    		System.out.println(b);
    		System.out.println(c);
    		System.out.println(b==c);
    	}
    }

以上的运行结果是：  
true  
6  
5  
false  
这似乎和我们之前的例子不一样了。c和b都指向同一个地址，所以第一次bc是true的，但当b加1之后，c并没有跟着b加1，  
bc变成了false，说明两个指向的地址已经不是同一个了。  
一开始对这个可能无法理解，我们先看看下面的例子：

public class Test {
    	public static void main(String[] args) {
    		int x = 1;
    		int y = x;
    		x = x+1;
    		System.out.println(y==x);
    	}
    }

输出是false，这个我们很容易知道，一开始x和y都是1，当x加1之后，x是2，y还是1，所以yx是false的，数值型的变量在判断时是直接比较他们的值的。

再回忆一下java的装箱和拆箱：  
所谓装箱，就是把基本类型用它们相对应的引用类型包起来，使它们可以具有对象的特质，如我们可以把int型包装成Integer类的对象，或者把double包装成Double，等等。  
所谓拆箱，就是跟装箱的方向相反，将Integer及Double这样的引用类型的对象重新简化为值类型的数据。  
JDK1.5之后可自动进行装箱和拆箱的操作，例子如下：

int i=10;
    Integer j=Integer.valueOf(i); //手动装箱操作
    int k=j.intValue();//手动拆箱操作
    
    int i1=10
    Integer j1=i1;//自动装箱操作
    int k1=j1;//自动拆箱操作

通过上面的讲解应该就知道原因了：

Integer b = new Integer(5);
    	Integer c = b;
    	System.out.println(b==c);//现在两个指向同一个地址，是true的
    	b = b+1;//b是包装类，得拆箱成数值型，然后加1，变成数值6，然后把数值6再装箱变成包装类赋给b，等同于b=Integer.valueOf(b.intValue()+1);
    	//Integer.valueOf()会生成一个新的包装类对象(因为valueOf()方法的源码里写着，return的是new Integer()，源码见下)
    	System.out.println(b==c);//现在两个指向不同的地址，是false的

终于真相大白了，上面的问题告一段落，我自以为对包装类很懂了，但再看看下面的题目：

Integer b = 128;
    	Integer c = 128;
    	System.out.println(b==c);

输出是false，这很好理解，128是数值型的，再赋值给包装类变量时先要装箱，上面的等同于：

Integer b = Integer.valueOf(128);
    		Integer c = Integer.valueOf(128);
    		System.out.println(b==c);

这样很明显可以看成是false的，是两个不同的对象。  
再看看这个：

Integer b = 100;
    		Integer c = 100;
    		System.out.println(b==c);

输出居然是true。小学生表示已经崩溃，是不是对java已经无爱了。但是我可不会就这样放弃，到底是什么原因呢？  
查看Integer的valueOf方法的源码如下：

public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { // must cache 
        return IntegerCache.cache[i + offset];
    }
        return new Integer(i);
    }

于是明白了，在【-128，127】之间的数字，valueOf()返回的是缓存中的对象，所以两次调用返回的是同一个对象。  
也就是说Integer(100)这样的对象已经有了一个了，自动装箱之前就不去new了，直接使用缓存里的，所以是同一个对象，指向的是同一个引用地址。  
以上代码等同于:

Integer b = Integer.valueOf(100);
    		Integer c = Integer.valueOf(100);
    		System.out.println(b==c);

所以输出是true。  
接下来下面这个也很明白了吧：

Integer a = new Integer(100);  
        Integer b = 100;  
        System.out.println(a == b);

输出的是false，因为a是自己new的对象，不是通过valueOf获取的，没有放进缓存里，所以b在valueOf时还是会new一个  
以上代码等同于：

Integer a = new Integer(100);  
      	Integer b = Integer.valueOf(100);  
        System.out.println(a == b);

这样就看的出来是false了。  
总之以上的现象只会在拆装箱，或者你自己手动调用valueOf方法时才会出现！