覆盖equals【引自http://www.javapractices.com/Topic17.cjp】

Implementing equalsDiscussion:
All objects have both identity (the object's location in memory) and state (the object's data). The == operator always compares identity. The default implementation of equals compares identity as well.

Sometimes the default implementation of equals has the desired behaviour (as in a type-safe enumeration, for example), but  equals should usually compare state, not identity. This is particularly true for "data-centric" classes which map to database records.

hashCode and equals are closely related :

• if you override equals, you must override hashCode
• hashCode must generate equal values for equal objects

Objects placed in a List , Set, or Map (as either a key or value) should have an appropriate definition of equals. (See, for example, the javadoc for Collection.contains , Map.containsKey, and Map.containsValue .)

If you extend a concrete class, and add a new field which contributes to equals, then it is not possible to write a perfectly correct equals method for the new class. Instead, you should use composition instead of inheritance.

Example

Here is an implementation of equals for a data-centric class. It demonstrates how different types of fields are treated:

• object fields, including collections : use equals
• type-safe enumerations : use either equals or == (they amount to the same thing, in this case)
• possibly-null object fields : use both == and equals
• array fields : use Arrays.equals
• primitive fields other than float or double : use ==
• float : convert to int using Float.floatToIntBits, then use ==
• double :  convert to long using Double.doubleToLongBits, then use ==

It is worth noting that if fields are implemented with wrapper classes (Integer, Boolean, and so on), then implementation of equals is simpler, since there is only one case : calling the equals method recursively. (The compareTo method is also simplified in this case.)

The above policies can be collected in a utility class :

import java.util.Arrays;/*** Collected methods which allow easy implementation of <code>equals</code>.** Example use case in a class called Car:* <pre>public boolean equals(Object that){  if ( this == that ) return true;  if ( !(that instanceof Car) ) return false;  Car thatCar = (Car)that;  return    EqualsUtil.areEqual(this.fName, that.fName) &&    EqualsUtil.areEqual(this.fNumDoors, that.fNumDoors) &&    EqualsUtil.areEqual(this.fGasMileage, that.fGasMileage) &&    EqualsUtil.areEqual(this.fColor, that.fColor) &&    Arrays.equals(this.fMaintenanceChecks, that.fMaintenanceChecks); //array!}* </pre>** <em>Arrays are not handled by this class</em>.* This is because the <code>Arrays.equals</code> methods should be used for* array fields.*/public final class EqualsUtil {  static public boolean areEqual(boolean aThis, boolean aThat){    //System.out.println("boolean");    return aThis == aThat;  }  static public boolean areEqual(char aThis, char aThat){    //System.out.println("char");    return aThis == aThat;  }  static public boolean areEqual(long aThis, long aThat){    /*    * Implementation Note    * Note that byte, short, and int are handled by this method, through    * implicit conversion.    */    //System.out.println("long");    return aThis == aThat;  }  static public boolean areEqual(float aThis, float aThat){    //System.out.println("float");    return Float.floatToIntBits(aThis) == Float.floatToIntBits(aThat);  }  static public boolean areEqual(double aThis, double aThat){    //System.out.println("double");    return Double.doubleToLongBits(aThis) == Double.doubleToLongBits(aThat);  }  /**  * Possibly-null object field.  *  * Includes type-safe enumerations and collections, but does not include  * arrays. See class comment.  */  static public boolean areEqual(Object aThis, Object aThat){    //System.out.println("Object");    return aThis == null ? aThat == null : aThis.equals(aThat);  }} 

Car is a class which uses EqualsUtil to implement its equals method :

import java.util.*;public final class Car {  public Car (    String aName,    int aNumDoors,    List<String> aOptions,    double aGasMileage,    String aColor,    Date[] aMaintenanceChecks  ){    fName = aName;    fNumDoors = aNumDoors;    fOptions = new ArrayList<String>(aOptions);    fGasMileage = aGasMileage;    fColor = aColor;    fMaintenanceChecks = new Date[aMaintenanceChecks.length];    for (int idx=0; idx < aMaintenanceChecks.length; ++idx) {      fMaintenanceChecks[idx] = new Date( aMaintenanceChecks[idx].getTime() );    }  }  public boolean equals(Object aThat) {    //check for self-comparison    if ( this == aThat ) return true;    //use instanceof instead of getClass here for two reasons    //1. if need be, it can match any supertype, and not just one class;    //2. it renders an explict check for "that == null" redundant, since    //it does the check for null already - "null instanceof [type]" always    //returns false. (See Effective Java by Joshua Bloch.)    if ( !(aThat instanceof Car) ) return false;    //Alternative to the above line :    //if ( aThat == null || aThat.getClass() != this.getClass() ) return false;    //cast to native object is now safe    Car that = (Car)aThat;    //now a proper field-by-field evaluation can be made    return      EqualsUtil.areEqual(this.fName, that.fName) &&      EqualsUtil.areEqual(this.fNumDoors, that.fNumDoors) &&      EqualsUtil.areEqual(this.fOptions, that.fOptions) &&      EqualsUtil.areEqual(this.fGasMileage, that.fGasMileage) &&      EqualsUtil.areEqual(this.fColor, that.fColor) &&      Arrays.equals(this.fMaintenanceChecks, that.fMaintenanceChecks);  }  //..other methods elided  // PRIVATE ////  /**  * The following fields are chosen to exercise most of the different  * cases.  */  private String fName;  private int fNumDoors;  private List<String> fOptions;  private double fGasMileage;  private String fColor; //treat as possibly-null  private Date[] fMaintenanceChecks;  /**  * Exercise the equals method.  */  public static void main (String[] aArguments) {    List<String> options = new ArrayList<String>();    options.add("sunroof");    Date[] dates = new Date[1];    dates[0] = new Date();    //Create a bunch of Cars; only one and two should be equal    Car one = new Car("Nissan", 2, options, 46.3, "Green", dates);    //two is equal to one    Car two = new Car("Nissan", 2, options, 46.3, "Green", dates);    //three has a differs in fName only    Car three = new Car("Pontiac", 2, options, 46.3, "Green", dates);    //four differs in fNumDoors only    Car four = new Car("Nissan", 4, options, 46.3, "Green", dates);    //five differs in fOptions only    List<String> optionsTwo = new ArrayList<String>();    optionsTwo.add("air conditioning");    Car five = new Car("Nissan", 2, optionsTwo, 46.3, "Green", dates);    //six differs in fGasMileage only    Car six = new Car("Nissan", 2, options, 22.1, "Green", dates);    //seven differs in fColor only    Car seven = new Car("Nissan", 2, options, 46.3, "Fuchsia", dates);    //eight differs in fMaintenanceChecks only    Date[] datesTwo = new Date[1];    datesTwo[0] = new Date(1000000);    Car eight = new Car("Nissan", 2, options, 46.3, "Green", datesTwo);    System.out.println( "one = one: " + one.equals(one) );    System.out.println( "one = two: " + one.equals(two) );    System.out.println( "two = one: " + two.equals(one) );    System.out.println( "one = three: " + one.equals(three) );    System.out.println( "one = four: " + one.equals(four) );    System.out.println( "one = five: " + one.equals(five) );    System.out.println( "one = six: " + one.equals(six) );    System.out.println( "one = seven: " + one.equals(seven) );    System.out.println( "one = eight: " + one.equals(eight) );    System.out.println( "one = null: " + one.equals(null) );  }} 

An example run of this class demonstrates that only objects one and two are equal :
one = one: true
one = two: true
two = one: true
one = three: false
one = four: false
one = five: false
one = six: false
one = seven: false
one = eight: false
one = null: false