java基础(五) equals hashcode

  Object类中的equals方法用于检测一个对象是否等于另一个对象。在Object类中，这个方法将判断两个对象是否具有相同的引用。

    /**
     * Indicates whether some other object is "equal to" this one.
     * <p>
     * The <code>equals</code> method implements an equivalence relation
     * on non-null object references:
     * <ul>
     * <li>It is <i>reflexive</i>: for any non-null reference value
     *     <code>x</code>, <code>x.equals(x)</code> should return
     *     <code>true</code>.
     * <li>It is <i>symmetric</i>: for any non-null reference values
     *     <code>x</code> and <code>y</code>, <code>x.equals(y)</code>
     *     should return <code>true</code> if and only if
     *     <code>y.equals(x)</code> returns <code>true</code>.
     * <li>It is <i>transitive</i>: for any non-null reference values
     *     <code>x</code>, <code>y</code>, and <code>z</code>, if
     *     <code>x.equals(y)</code> returns <code>true</code> and
     *     <code>y.equals(z)</code> returns <code>true</code>, then
     *     <code>x.equals(z)</code> should return <code>true</code>.
     * <li>It is <i>consistent</i>: for any non-null reference values
     *     <code>x</code> and <code>y</code>, multiple invocations of
     *     <tt>x.equals(y)</tt> consistently return <code>true</code>
     *     or consistently return <code>false</code>, provided no
     *     information used in <code>equals</code> comparisons on the
     *     objects is modified.
     * <li>For any non-null reference value <code>x</code>,
     *     <code>x.equals(null)</code> should return <code>false</code>.
     * </ul>
     * <p>
     * The <tt>equals</tt> method for class <code>Object</code> implements 
     * the most discriminating possible equivalence relation on objects; 
     * that is, for any non-null reference values <code>x</code> and
     * <code>y</code>, this method returns <code>true</code> if and only
     * if <code>x</code> and <code>y</code> refer to the same object
     * (<code>x == y</code> has the value <code>true</code>).
     * <p>
     * Note that it is generally necessary to override the <tt>hashCode</tt>
     * method whenever this method is overridden, so as to maintain the
     * general contract for the <tt>hashCode</tt> method, which states
     * that equal objects must have equal hash codes. 
     *
     * @param   obj   the reference object with which to compare.
     * @return  <code>true</code> if this object is the same as the obj
     *          argument; <code>false</code> otherwise.
     * @see     #hashCode()
     * @see     java.util.Hashtable
     */
    public boolean equals(Object obj) {
	return (this == obj);
    }

 

在注释中，是java语言规范对equals方法所具有特性的说明。

1) 自反性：对于任何非空应用x，x.equals(x)应该返回true.

2) 对称性：对于任何引用x和y，当且仅当y.equals(x)返回true，x.equals(y)也应该返回true.

3) 传递性：对于任何引用x、y、z,如果x.qeuals(y)返回true,y.equals(z)返回true,x.equals(z)也应该返回true.

4) 一致性：如果x和y引用的对象没有发生变化，反复调用x.equals(y)应该返回同样的结果。

5) 对于任意非空引用x，x.equals(null)应该返回false

 

如何编写一个完美的equals方法的建议：

1) 显式参数名为otherObject,稍后需要将它转换成另一个叫做other的变量

2) 检测this与otherObject是否引用同一个对象

if(this == otherObject) return true;

3) 检测otherObject是否为null,如果为null,返回false。

if(otherObject == null) return false;

4)比较this与otherObject是否属于同一类。如果equals的语义在每一个子类中有所改变，就使用getClass检测。

if(getClass() != otherObject.getClass() ) return false;

如果所有的子类都拥有统一的语义，就使用instanceof检测：

if(!(otherObject instanceof ClassName)) return false;

5) 将otherObject转换为相应的类类型变量：

ClassName other = (ClassName) otherObject;

6) 使用 ==比较基本类型域，用equals比较对象域。如果所有的域都匹配，就返回true.否则返回false;

如果在子类中重新定义equals，就要在其中包含调用super.equals(other)

 

散列码(hash code)是由对象导出的一个整型值。每个对象都有一个默认的散列码，其值为对象的存储地址。在Object中默认的hashcode方法导出的是对象的存储地址。

    /**
     * Returns a hash code value for the object. This method is 
     * supported for the benefit of hashtables such as those provided by 
     * <code>java.util.Hashtable</code>. 
     * <p>
     * The general contract of <code>hashCode</code> is: 
     * <ul>
     * <li>Whenever it is invoked on the same object more than once during 
     *     an execution of a Java application, the <tt>hashCode</tt> method 
     *     must consistently return the same integer, provided no information 
     *     used in <tt>equals</tt> comparisons on the object is modified.
     *     This integer need not remain consistent from one execution of an
     *     application to another execution of the same application. 
     * <li>If two objects are equal according to the <tt>equals(Object)</tt>
     *     method, then calling the <code>hashCode</code> method on each of 
     *     the two objects must produce the same integer result. 
     * <li>It is <em>not</em> required that if two objects are unequal 
     *     according to the {@link java.lang.Object#equals(java.lang.Object)} 
     *     method, then calling the <tt>hashCode</tt> method on each of the 
     *     two objects must produce distinct integer results.  However, the 
     *     programmer should be aware that producing distinct integer results 
     *     for unequal objects may improve the performance of hashtables.
     * </ul>
     * <p>
     * As much as is reasonably practical, the hashCode method defined by 
     * class <tt>Object</tt> does return distinct integers for distinct 
     * objects. (This is typically implemented by converting the internal 
     * address of the object into an integer, but this implementation 
     * technique is not required by the 
     * Java<font size="-2"><sup>TM</sup></font> programming language.)
     *
     * @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     java.util.Hashtable
     */
    public native int hashCode();

 

Equals与hashCode的定义必须一致：如果x.equals(y)返回为true，那么x.hashCode()就必须与y.hashCode()具有相同的值。