java中的equals()方法重寫

如何java中默認的equals方法跟實際不符的話，需要重寫equals方法。例如：

public class TestEquals {
public static void main(String[] args) {
 Cat c1 = new Cat (1,2,3);
 Cat c2 = new Cat (1,2,3);
 System.out.println(c1==c2);
 System.out.println(c1.equals(c2));
}
}
 class Cat{
 int color ;
  int height ;
  int weight ;
 
  public Cat(int color, int height, int weight){
   this.color = color ;
   this.height = height ;
   this.weight = weight ;
  }
 
  public boolean equals(Object obj){
   if (obj == null) return false ;
   else{
    if (obj instanceof Cat){
    Cat c = (Cat) obj;
    if(c.color== this.color && c.height == this.height && c.weight == this.weight){
     return true ;
    }
   }
   }
  return false ;
    }
 }

 

 

在上面的例子中，如果不寫equals方法，打印出來的都是false，跟實際不符。

 

注：instanceof操作符的解釋

instanceof 是一個運算符， 用於判斷一個對象是不是屬於一個類 當左邊是右邊的一個對象時 返回true ； if在這是用於判斷你傳入的對象是否是Person類的對象，如果不是就不用運行下面的代碼，不是同一類對象無法比較！如果不判斷，當其他類對象時，編譯不會報錯，運行會出錯ClassCastException ，因為不是Cat類,Cat p = (Cat)obj，向下轉型失敗

 

 

每個覆蓋了equals方法的類中，也必須覆蓋hashCode方法。

如果不這樣的話，就會違反Object.hashCode的通用約定，從而導致該類無法結合所有基於散列的集合一起正常運作，這樣的集合包括HashMap、HashSet和Hashtable。

在引用程序的執行期間，只要對象的equals方法的比較操作所用到的信息沒有被修改，那么對這同一個對象調用多次，hashCode方法都必須始終如一的返回同一個整數。在一個應用程序的多次執行過程中，每次執行所返回的整數可以不一致。

如果連個對象根絕equals方法比較是相等的，那么調用這兩個對象中任意一個對象的hashCode方法都必須產生同樣的整數結果。

如果兩個對象根據equals方法比較是不相等的，那么調用這兩個對象中任意一個對象的hashCode方法，則不一定要蠶聲不同的整數結果。但是程序員應該知道，給不相等的對象產生截然不同的整數結果，有可能提高散列表（hash table）的性能。（比如，當你一個entity只根據id比較是否相等，但是在沒實例化之前，沒有id數值，那么默認的equals返回false，但是hashCode返回的值卻相等。）

Java代碼

import java.util.*;

public final class PhoneNumber {

private final short areaCode;

private final short prefix;

private final short lineNumber;

   public PhoneNumber(int areaCode, int prefix,

   int lineNumber) {

    rangeCheck(areaCode, 999, "area code");

    rangeCheck(prefix, 999, "prefix");

    rangeCheck(lineNumber, 9999, "line number");

    this.areaCode = (short) areaCode;

    this.prefix = (short) prefix;

    this.lineNumber = (short) lineNumber;

}

 

 private static void rangeCheck(int arg, int max,

   String name) {

   if (arg < 0 || arg > max)

   throw new IllegalArgumentException(name +": " + arg);

   }

 

 @Override public boolean equals(Object o) {

  if (o == this)

  return true;

  if (!(o instanceof PhoneNumber))

 return false;

 PhoneNumber pn = (PhoneNumber)o;

 return pn.lineNumber == lineNumber

 && pn.prefix == prefix

 && pn.areaCode == areaCode;

 }

 

 // Broken - no hashCode method!

 

 // A decent hashCode method - Page 48

 // @Override public int hashCode() {

 // int result = 17;

 // result = 31 * result + areaCode;

 // result = 31 * result + prefix;

 // result = 31 * result + lineNumber;

 // return result;

 // }

 

 

 // Lazily initialized, cached hashCode - Page 49

 // private volatile int hashCode; // (See Item 71)

 //

 // @Override public int hashCode() {

 // int result = hashCode;

 // if (result == 0) {

 // result = 17;

 // result = 31 * result + areaCode;

 // result = 31 * result + prefix;

 // result = 31 * result + lineNumber;

 // hashCode = result;

 // }

 // return result;

 // }

 

    public static void main(String[] args) {

     Map<PhoneNumber, String> m

      = new HashMap<PhoneNumber, String>();

     m.put(new PhoneNumber(707, 867, 5309), "Jenny");

    System.out.println(m.get(new PhoneNumber(707, 867, 5309)));

    }

}