java中的==、equals()、hashCode()源码分析

转载自：http://www.cnblogs.com/xudong-bupt/p/3960177.html

在Java编程或者面试中经常会遇到 == 、equals()的比较。自己看了看源码，结合实际的编程总结一下。

1. == 

　　Java中的==是比较两个对象在JVM中的地址。比较好理解。看下面的代码：

 public class ComAddr{
     public static void main(String[] args) throws Exception {
         String s1 = "nihao";
         String s2 = "nihao";
         String s3 = new String("nihao");
         System.out.println(s1 == s2);    //    true
         System.out.println(s1 == s3);    //    false
     }
 }

　　上述代码中：

　　(1)s1 == s2为true，是因为s1和s2都是字符串字面值"nihao"的引用，指向同一块地址，所以相等。

　　(2)s1 == s3为false，是因为通过new产生的对象在堆中，s3是堆中变量的引用，而是s1是指向字符串字面值"nihao"的引用，地址不同所以不相等。

2.equals()

　　equals是根类Obeject中的方法。源代码如下：

public boolean equals(Object obj) {
    return (this == obj);
}

　　可见默认的equals方法，直接调用==，比较对象地址。

　 不同的子类，可以重写此方法，进行两个对象的equals的判断。

　　String类源码中重写的equals方法如下，

     public boolean equals(Object anObject) {
         if (this == anObject) {
             return true;
         }
         if (anObject instanceof String) {
             String anotherString = (String) anObject;
             int n = value.length;
             if (n == anotherString.value.length) {
                 char v1[] = value;
                 char v2[] = anotherString.value;
                 ;
                 ) {
                     if (v1[i] != v2[i])
                             return false;
                     i++;
                 }
                 return true;
             }
         }
         return false;
     }

　　从上面的代码中可以看到，

　　(1)String类中的equals首先比较地址，如果是同一个对象的引用，可知对象相等，返回true。

　　(2)若果不是同一个对象，equals方法挨个比较两个字符串对象内的字符，只有完全相等才返回true，否则返回false。

3.hashcode()

　　hashCode是根类Obeject中的方法。

　　默认情况下，Object中的hashCode() 返回对象的32位jvm内存地址。也就是说如果对象不重写该方法，则返回相应对象的32为JVM内存地址。

public class Hello {

    public static void main(String args[]) {
        String str = "Hello";
        System.out.println(str.hashCode());
    }
}

执行上面的代码，控制台将打印出：

而String类源码中重写了 hashCode方法，源代码如下：

 public int hashCode() {
     int h = hash;    //Default to 0 ### String类中的私有变量，
     if (h == 0 && value.length > 0) {    //private final char value[]; ### Sting类中保存的字符串内容的的数组
         char val[] = value;

         for (int i = 0; i < value.length; i++) {
             h = 31 * h + val[i];
         }
         hash = h;
     }
     return h;
 }

　　String源码中使用private final char value[];保存字符串内容，因此String是不可变的。

　　看下面的例子，没有重写hashCode方法的类，直接返回32位对象在JVM中的地址；Long类重写了hashCode方法，返回计算出的hashCode数值：

 public class ComHashcode{
     public static void main(String[] args) throws Exception {
         ComHashcode a = new ComHashcode();
         ComHashcode b = new ComHashcode();
         System.out.println(a.hashCode());
         System.out.println(b.hashCode());    

         Long num1 = new Long(8);
         Long num2 = new Long(8);
         System.out.println(num1.hashCode());
         System.out.println(num2.hashCode());
     }
 }

总的来说：== 比较对象在JVM中的地址。 equals 默认也是比较对象在 JVM 中的地址，但子类可重写该方法实现个性化需求。hashcode 默认返回 对象的 32 位 JVM 内存地址，但子类也可以通过重写该方法实现个性化需求。

除了上面所说的关系之外，equals() 和 hashCode() 还有一些关联特性：

(1)绑定。当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码，即如果两个对象 equals() 相等，那么其调用 hashCode() 的返回值也应该相同。

(2)绑定原因。Hashtable实现一个哈希表，为了成功地在哈希表中存储和检索对象，用作键的对象必须实现 hashCode 方法和 equals 方法。同(1)，必须保证equals相等的对象，hashCode 也相等。因为哈希表通过hashCode检索对象。

参考：

http://docs.oracle.com/Javase/7/docs/api/