equals()和hashCode()方法

ゝ一纸荒年。 2022-07-16 23:50 259阅读 0赞

一个类用一个成员变量x，另一个类继承了该类，构造方法调用了父类的构造方法，，如何实现equals()方法和hashCode()方法，使两个类对象比较时对象相等，hashCode相等？

一、初识equals()和hashCode()方法

1、首先需要明确知道的一点是：hashCode()方法和equals()方法是在Object类中就已经定义了的，所以在java中定义的任何类都会有这两个方法。原始的equals()方法用来比较两个对象的地址值，而原始的hashCode()方法用来返回其所在对象的物理地址，下面来看一下在Object中的定义:

**equals:**

public boolean equals(Object obj) \{//**很明显,比较的是两个对象的地址是否相同**  
 return (this == obj);  
    \}

**hashCode:**  
public native int hashCode();//**由native修饰，对应一个本地实现**

2、如果定义了一个类A，只要它没有重写这两个方法，这两个方法的意义就是如上面所述。请看下面的示例:

**示例一**

public class Test\{  
 public static void main(String args\[\])\{  
  Demo d1=new Demo(1,”abc“);  
  Demo d2=new Demo(1,”abc“);  
    
  System.out.println(d1.equals(d2));//**输出false，虽然d1和d2的参数都是(1,abc)，但是他们指向不同的内存地址**  
  System.out.println(d1.hashCode());  
  System.out.println(d2.hashCode());//**d1和d2的hashCode不同**  
 \}  
\}

class Demo\{  
 int a;  
 String b;  
 public Demo(int a,String b)\{  
  this.a=a;  
  this.b=b;  
 \}  
\}

**二、equals()和hashCode()的重写**

前面说到，因为这两个方法都是在Object类中定义，所以java中定义的所有类都会有这两个方法，并且根据实际需要可以重写这两个方法，当方法被重写后，他们所代表的意义就会发生变化，看下面的代码:

**示例二**

public class TestString\{  
 public static void main(String args\[\])\{  
  String s1=new String("abc");  
  String s2=new String("abc");  
  System.out.println(s1.equals(s2));//**输出true，因为String类重写了equals()方法，虽然s1和s2此时指向的地址空间不同，它比较的不再是地址而是String的内容，** **此时s1和s2都是"abc"，故返回true**  
  System.out.println(s1.hashCode());  
  System.out.println(s2.hashCode());//你会发现**s1和s2的hashCode相同，因为String同样重写了hashCole()方法，返回的不再是地址，而是根据具体的字符串算出的一个值**  
 \}  
\}

**三、equals()和hashCode()方法是怎样被重写的**

**1、我们来看一下String类中这两个方法的定义:**

**equals()方法:**

public boolean equals(Object anObject) \{  
 if (this == anObject) \{//**首先进行两个对象地址的比较，如果地址相同了，那么，对象的内容也肯定相同**  
     return true;  
 \}  
 if (anObject instanceof String) \{//**比较两个String对象的内容是否相同，相同返回true，不同返回false**  
     String anotherString = (String)anObject;  
     int n = count;  
     if (n == anotherString.count) \{  
  char v1\[\] = value;  
  char v2\[\] = anotherString.value;  
  int i = offset;  
  int j = anotherString.offset;  
  while (n-- != 0) \{  
      if (v1\[i++\] != v2\[j++\])  
   return false;  
  \}  
  return true;  
     \}  
 \}  
 return false;  
    \}  
**hashCode()方法:**

public int hashCode() \{  
 int h = hash;  
 if (h == 0) \{  
     int off = offset;  
     char val\[\] = value;  
     int len = count;

for (int i = 0; i < len; i++) \{//**通过一个特定的[算法][Link 1]算出一个hash值，此时的hash值不是对象的地址，而是决定于String的内容是什么，只要两个字符串内容相同，他们的hashCode就相同**  
                h = 31\*h + val\[off++\];  
            \}  
            hash = h;  
        \}  
        return h;  
    \}

**2、下面我们改写****示例一****的代码，对equals和hashCode进行重写：**  
**示例三(***粉色部分为改动的代码***)**

class Demo\{  
 int a;  
 String b;  
 public Demo(int a,String b)\{  
  this.a=a;  
  this.b=b;  
 \}  
   
 public int hashCode()\{  
  return a\*(b.hashCode());  
 \}  
   
 public boolean equals(Object o)\{  
  Demo d=(Demo)o;  
  return (this.a==d.a)&&(this.b.equals(d.b));  
 \}  
\}

public class Test\{  
 public static void main(String args\[\])\{  
  Demo d1=new Demo(1,"abc");  
  Demo d2=new Demo(1,"abc");  
    
  System.out.println(d1.equals(d2));//**输出为true，由于重写了equals()，此时比较的不再是对象地址，而是对象内容此时两个对象的内容都是(1,abc)**  
  System.out.println(d1.hashCode());  
  System.out.println(d2.hashCode());//**d1和d2的hash值相同，由于重写了hashCode (),此时返回的不再是地址，而是根据对象内容算出的一个值**  
 \}  
\}

**3、小结**

1、String 、Math、Integer以及Double等这些封装类已经对equals()和hashCode()方法进行了重写，这两个方法在这些类中已经改变了其本来意义；

2、如果X.equals(Y)，那么它们的X和Y的hashCode值一定相同(这也是java规范中规定的)，不管equals进行的是地址比较还是内容比较；

3、如果两个对象X和Y的hashCode相同，但是X.equals(Y)不一定成立(比如:如果示例三中只重写了hashCode方法，没有重写equals方法，那么System.out.println(d1.equals(d2))一定会输出**false**)；

[Link 1]: http://lib.csdn.net/base/31