java关于hashCode()方法的一些理解

今天药忘吃喽~ 2022-02-23 15:34 265阅读 0赞

## java关于hashCode()方法的一些理解 ##

1.  它是Object 类中的native方法。如果对象中不去实现自己的hashCode（）方法，那么就使用虚拟机提供的本地方法，一般是通过将该对象的内部地址转换成一个整数来实现的。
2.  它的注释说明了很多它的特性。
    
     *  在程序执行期间，只要equals方法的比较操作用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法必须始终如一地返回同一个整数。
     *  如果两个对象根据equals方法比较是相等的，那么调用两个对象的hashCode方法必须返回相同的整数结果。
     *  如果两个对象根据equals方法比较是不等的，则hashCode方法不一定得返回不同的整数。然后，程序员应该注意到对于不相等的对象产生不同的整数哈希值结果可以提高哈希表的性能。

/** * Returns a hash code value for the object. This method is * supported for the benefit of hash tables such as those provided by * {@link java.util.HashMap}. * * The general contract of {@code hashCode} is: * <ul> * <li>Whenever it is invoked on the same object more than once during * an execution of a Java application, the {@code hashCode} method * must consistently return the same integer, provided no information * used in {@code equals} 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 {@code equals(Object)} * method, then calling the {@code hashCode} 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 {@code hashCode} 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 hash tables. * </ul> * * As much as is reasonably practical, the hashCode method defined by * class {@code Object} 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™ programming language.) * * @return a hash code value for this object. * @see java.lang.Object#equals(java.lang.Object) * @see java.lang.System#identityHashCode */
 public native int hashCode();

1. 注释中第一句就说了，This method is supported for the benefit of hash tables such as those provided by \* \{@link java.util.HashMap\}。hashCode()方法对使用哈希表结构的集合很有益。
 
 例如：如果没有哈希值，从hashMap中查找一个键值对，除了逐个的使用equals()方法比较再无办法，这就很浪费时间。有了hashCode，可以直接根据哈希值比较，哈希值不相同，那么两个key对象肯定不相同。如果相同的时候，再使用equals方法，逐个比较该位置的链表（java8以后，还可能是红黑树）中的元素。
2. 常用的类型，Integer、String都有自己的hashCode实现。Integer是返回自己包装的int值，String是用公式s\[0\]\*31^(n-1) + s\[1\]\*31^(n-2) + … + s\[n-1\]计算。
 
 Integer:
 
 private final int value;
 
 @Override
 public int hashCode() { 
 return Integer.hashCode(value);
 }
 
 public static int hashCode(int value) { 
 return value;
 }
 
 String:
 
 /** * Returns a hash code for this string. The hash code for a * {@code String} object is computed as * <blockquote><pre> * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] * </pre></blockquote> * using {@code int} arithmetic, where {@code s[i]} is the * ith character of the string, {@code n} is the length of * the string, and {@code ^} indicates exponentiation. * (The hash value of the empty string is zero.) * * @return a hash code value for this object. */
 public int hashCode() { 
 int h = hash;
 if (h == 0 && value.length > 0) { 
 char val[] = value;
 
 for (int i = 0; i < value.length; i++) { 
 h = 31 * h + val[i];
 }
 hash = h;
 }
 return h;
 }
3. 所以，重写equals()方法和hashCode()的话，要遵守上面2中的原则。否则可能产生歧义和程序错误。
 
 例如： 我们重写了一个对象的equals()方法，让它们的属性都相等的时候，就认为是相等的。此时不重写hashCode()，那么此时它们的hashCode是不同的，因为两个对象，地址肯定时不同的，与地址关联的hashCode值就是不同的。当这个对象存储在HashMap中的时候，我们想get一个元素的时候，看似相同的key, 却不能取到相同的value。因为HashMap源码中，get的实现是先比较hashCode，再equals比较的。
 
 /** * Implements Map.get and related methods. * * @param hash hash for key * @param key the key * @return the node, or null if none */
 final Node<K,V> getNode(int hash, Object key) { 
 Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
 if ((tab = table) != null && (n = tab.length) > 0 &&
 (first = tab[(n - 1) & hash]) != null) { 
 if (first.hash == hash && // always check first node
 ((k = first.key) == key || (key != null && key.equals(k))))
 return first;
 if ((e = first.next) != null) { 
 if (first instanceof TreeNode)
 return ((TreeNode<K,V>)first).getTreeNode(hash, key);
 do { 
 if (e.hash == hash &&
 ((k = e.key) == key || (key != null && key.equals(k))))
 return e;
 } while ((e = e.next) != null);
 }
 }
 return null;
 }
 
 比较的语句是下面的两句，都是在hash值相等的时候，再去equals比较的。
 
 if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
 和
 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))