Java中 hashCode（）方法详解

Z时代
2024-01-10
分类：综合

java

先来看下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>.
 * 
 * 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 not 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>
 * 
 * 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
 * JavaTM 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（），也就是我们重写equals（）的时候也要重写hashCode（）...

我们在来看下hashTable的实现：

    /**
     * Returns the hash code value for this Map as per the definition in the
     * Map interface.
     *
     * @see Map#hashCode()
     * @since 1.2
     */
   // 计算Hashtable的哈希值

public synchronized int hashCode() {
 /*
 * This code detects the recursion caused by computing the hash code
 * of a self-referential hash table and prevents the stack overflow
 * that would otherwise result. This allows certain 1.1-era
 * applets with self-referential hash tables to work. This code
 * abuses the loadFactor field to do double-duty as a hashCode
 * in progress flag, so as not to worsen the space performance.
 * A negative load factor indicates that hash code computation is
 * in progress.
 */
 int h = 0;
 if (count == 0 || loadFactor < 0)
 return h; // Returns zero

 loadFactor = -loadFactor; // Mark hashCode computation in progress
 Entry[] tab = table;
 for (int i = 0; i < tab.length; i++)
 for (Entry e = tab[i]; e != null; e = e.next)
 h += e.key.hashCode() ^ e.value.hashCode(); //否则，返回“Hashtable中的每个Entry的key和value的异或值的总和”。
 loadFactor = -loadFactor; // Mark hashCode computation complete

 return h;
 }