equals和==的区别

想起前段时间对 == 和 equals的区别搞大了脑子，后来通过查资料和问人再瞎琢磨，倒是有点意思了

==：用于比较常量的话，就是比较常量的值，如果用来比较对象的话，那就是对象的内存地址了。

equals：如果没重写equals方法的话（下面有介绍），它跟 == 是一样的，如果重写了，那么equals比较是对象所指的值。

下面咱们用程序说话。

首先我们看下

1. String c = new String("tom");  
2. String d = new String("tom");  
3. System.out.println(d==c);   
4. System.out.println(d.equals(c));  

打印结果：false   true

首先我们看d == c,为什么是 false，因为 c d都是一个String对象，new了两次后，堆内存中就有了两块内容都是 tom的内存块，既然是两块的，那么内存地址肯定是不一样的了。

再看 d.equals(c),为什么是 true，咱们知道，String是覆写了 equals方法的，所以，它比较的是d和c所指向的堆内存中的tom，既然是比较值都是tom肯定相等了，所以为 true；

既然看完了上面的，应该有点了解吧，咱继续，这次我定义一个name类

view plain

1. class Name{  
2.       
3.     private String firstName;  
4.     private String lastName;  
5.       
6.     public Name(String firstName,String lastName){  
7.         this.firstName = firstName;  
8.         this.lastName = lastName;  
9.     }  
10.       
11.     public String getFirstName() {  
12.         return firstName;  
13.     }  
14.     public void setFirstName(String firstName) {  
15.         this.firstName = firstName;  
16.     }  
17.     public String getLastName() {  
18.         return lastName;  
19.     }  
20.     public void setLastName(String lastName) {  
21.         this.lastName = lastName;  
22.     }  
23.       
24.     public class Doubi {  
25.     public static void main(String[] args) {  
26.                   
27.                 Name a = new Name("1","1");  
28.                 Name b = new Name("1","1");  
29.                 System.out.println(a==b);  
30.                 System.out.println(a.equals(b));  
31.             }  
32.         }  

这时，你想想，这两个打印的是什么？false，true？不对，不对

这时打印的是 false，false。

这是为什么呢，因为Name类并没有重写 equals方法。

下面让我们看看 神秘的 equals方法是怎么样的吧

view plain

1. public boolean equals(Object o){  
2.      if(o instanceof Name){  
3.          Name name = (Name)o;  
4.          if(this.firstName.equals(name.getFirstName())   
5.                  && this.getLastName().equals(name.getLastName())){  
6.                
7.              return true;  
8.          }  
9.      }  
10.      return false;  
11.     }  

看到没，equals方法，它把对象所指向的值给取出来进行比较了，这就是为什么第一个例子中

 d.equals(c)是true，而这个例子中的

 a.equals(b)是false 了。

总结一下：

    == 比较常量的值，比较对象的话，就是比较它里面的指向堆内存的内存地址。

    equals 如果没有重写 equals方法（如上），它跟 == 是一样的效果

    如果equals方法被重写的话，比较就是 对象所指向的堆内存中里的内容

补充下：String a = new String("love");

你猜这段语句在在堆内存中建了几块内容是 love的内存块

不是一块！！  是两块！！

因为String 是不可变的，括号里（"love"），会自动生成一个内存块，但是它并没有谁指向它，过一段时间就会被GC（垃圾回收机制）回收掉。

new String（"love"）紧接着，它又new了一下，又出来一个love内容的内存块，但是它是有 a指向它的。

所以是两块。

这是我自个儿琢磨的结果...如果哪位大哥有不同看法，欢迎回复和补充，哈哈，谢了。。码字不容易啊