码迷,mamicode.com
首页 > 编程语言 > 详细

【Java实战】源码解析为什么覆盖equals方法时总要覆盖hashCode方法

时间:2017-05-15 23:49:52      阅读:266      评论:0      收藏:0      [点我收藏+]

标签:bucket   param   条件   main   class   默认   ble   替换   line   

1、背景知识

本文代码基于jdk1.8分析,《Java编程思想》中有如下描述:

技术分享

另外再看下Object.java对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}.
     * <p>
     * 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 <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 {@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>
     * <p>
     * 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();

对于3点约定翻译如下:

1)在java应用执行期间,只要对象的equals方法的比较操作所用到的信息没有被修改,那么对这同一对象调用多次hashCode方法都必须始终如一地同一个整数。在同一个应用程序的多次执行过程中,每次执行该方法返回的整数可以不一致。

2)如果两个对象根据equals(Object)方法比较是相等的,那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。

3)如果两个对象根据equals(Object)方法比较是不相等的,那么调用这两个对象中任意一个对象的hashCode方法没必要产生不同的整数结果。但是程序猿应该知道,给不同的对象产生截然不同的整数结果,有可能提高散列表(hash table)的性能。


因此,覆盖equals时总是要覆盖hashCode是一种通用的约定,而不是必须的,如果和基于散列的集合(HashMap、HashSet、HashTable)一起工作时,特别是将该对象作为key值的时候,一定要覆盖hashCode,否则会出现错误。那么既然是一种规范,那么作为程序猿的我们就有必要必须执行,以免出现问题。

下面就以HashMap为例分析其必要性

2、HashMap内部实现

常用形式如下:

public class PhoneNumber {
    private int areaCode;
    private int prefix;
    private int lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNumber = lineNumber;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        PhoneNumber that = (PhoneNumber) o;

        if (areaCode != that.areaCode) return false;
        if (prefix != that.prefix) return false;
        return lineNumber == that.lineNumber;
    }

    @Override
    public int hashCode() {
        int result = areaCode;
        result = 31 * result + prefix;
        result = 31 * result + lineNumber;
        return result;
    }

    public static void main(String[] args){
        Map<PhoneNumber,String> phoneNumberStringMap = new HashMap<PhoneNumber,String>();  1)初始化
        phoneNumberStringMap.put(new PhoneNumber(123, 456, 7890), "honghailiang");         2)put存储
        System.out.println(phoneNumberStringMap.get(new PhoneNumber(123, 456, 7890)));     3)get获取

    }
}
1)初始化
/**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

创建一个具有默认负载因子的HashMap,默认负载因子是0.75

2)put存储

/**
     * Associates the specified value with the specified key in this map.
     * If the map previously contained a mapping for the key, the old
     * value is replaced.
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @return the previous value associated with <tt>key</tt>, or
     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
     *         (A <tt>null</tt> return can also indicate that the map
     *         previously associated <tt>null</tt> with <tt>key</tt>.)
     */
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

通过注释可以看出,key值相同的情况下,会将前者覆盖,也就是HashMap中不允许存在重复的Key值。并且该方法是有返回值的,返回key值的上一个value,如果之前没有map则返回null。继续看putVal

/**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don‘t change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)      //tab为空则创建
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)               //根据下标获取,如果没有(没发生碰撞(hash值相同))则直接创建
            tab[i] = newNode(hash, key, value, null);
        else {                                                   //如果发生了碰撞进行如下处理
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)                      //为红黑数的情况
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {                                               //为链表的情况,普通Node
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null); //链表保存
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);                //如果链表长度超过了8则转为红黑树 
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key                     // 写入,并返回oldValue
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)          // 超过load factor*current capacity,resize
            resize();
        afterNodeInsertion(evict);
        return null;
    }


可以看到第一个参数时key的hash,如下

/**
     * Computes key.hashCode() and spreads (XORs) higher bits of hash
     * to lower.  Because the table uses power-of-two masking, sets of
     * hashes that vary only in bits above the current mask will
     * always collide. (Among known examples are sets of Float keys
     * holding consecutive whole numbers in small tables.)  So we
     * apply a transform that spreads the impact of higher bits
     * downward. There is a tradeoff between speed, utility, and
     * quality of bit-spreading. Because many common sets of hashes
     * are already reasonably distributed (so don‘t benefit from
     * spreading), and because we use trees to handle large sets of
     * collisions in bins, we just XOR some shifted bits in the
     * cheapest possible way to reduce systematic lossage, as well as
     * to incorporate impact of the highest bits that would otherwise
     * never be used in index calculations because of table bounds.
     */
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

综合考虑了速度、作用、质量因素,就是把key的hashCode的高16bit和低16bit异或了一下。因为现在大多数的hashCode的分布已经很不错了,就算是发生了碰撞也用O(logn)的tree去做了。仅仅异或一下,既减少了系统的开销,也不会造成的因为高位没有参与下标的计算(table长度比较小时),从而引起的碰撞。再回过头来看putVal

1.先判断存有Node数组table是否为null或者大小为0,如果是初始化一个tab并获取它的长度。resize()后面再说,先看下Node的结构

/**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }


Node实现了链表形式,用于存储hash值没有发生碰撞的hash、key、value,如果发生碰撞则用TreeNode存储,继承自Entry,并最终继承自Node

/**
     * Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn
     * extends Node) so can be used as extension of either regular or
     * linked node.
     */
    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }
......
}


2.以(n - 1) & hash为下标从tab中取出Node,如果不存在,则以hash、Key、value、null为参数new一个Node,存储到以(n - 1) & hash为下标的tab中

3.如果该下标中有值,也就是Node存在。如果为TreeNode,就用putTreeVal进行树节点的存储。否则以链表的形式存储,如果链表长度超过8则转为红黑树存储。

4.如果节点已经存在就替换old value(保证key的唯一性)

5.如果bucket(Node数组)满了(超过load factor*current capacity),就要resize。

总结:put存储过程:将K/V传给put方法时,它调用hashCode计算hash从而得到Node位置,进一步存储,HashMap会根据当前Node的占用情况自动调整容量(超过Load Facotr则resize为原来的2倍)。可见如果不覆盖hashCode就不能正确的存储。


3)get获取
看完put,再看下get
/**
     * Returns the value to which the specified key is mapped,
     * or {@code null} if this map contains no mapping for the key.
     *
     * <p>More formally, if this map contains a mapping from a key
     * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
     * key.equals(k))}, then this method returns {@code v}; otherwise
     * it returns {@code null}.  (There can be at most one such mapping.)
     *
     * <p>A return value of {@code null} does not <i>necessarily</i>
     * indicate that the map contains no mapping for the key; it‘s also
     * possible that the map explicitly maps the key to {@code null}.
     * The {@link #containsKey containsKey} operation may be used to
     * distinguish these two cases.
     *
     * @see #put(Object, Object)
     */
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

get方法又用到了hash(),是根据key的hash和key获取Node,返回的值就是Node的value属性。下面主要看下getNode方法即可
/**
     * 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) {                    //map中存在的情况,不存在则直接返回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);   //如果下一个节点是TreeNode,则用getTreeNode当时获取
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))    //循环节点链表,直到命中
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

1)第一个直接命中
2)否则,获取下一个节点,如果是红黑树,则从红黑树中获取,否则循环节点链表,直至命中。命中的条件是hash相等且key也相同(基本类型==,自定义类则用equals)。

总结:获取对象时,我们将K传给get,它调用hashCode计算hash从而得到Node位置,并进一步调用==或equals()方法确定键值对。可见为了正确的获取,要覆盖hashCode和equals方法

题外话:当链表长度超过8的时候,java8用红黑树代替了链表,目的是提高性能,这里不展开。HashMap是基于Map接口的实现,存储键值对时,它可以接收null的键值,是非同步的,HashMap存储着Entry(hash, key, value, next)对象。


3、为什么覆盖equals的时候要覆盖hashCode

通过HashMap的实现原理,可以看出当自定义类作为key值存在的时候一定要这样做,但不作为key值可以选择不这样做(但为了规范起见,还是要覆盖,因此就变成了必须的了)。如果将测试代码中的equals或hashCode注释掉都不能得到正确的结果:
public class PhoneNumber {
    private int areaCode;
    private int prefix;
    private int lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNumber = lineNumber;
    }

//    @Override
//    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (o == null || getClass() != o.getClass()) return false;
//
//        PhoneNumber that = (PhoneNumber) o;
//
//        if (areaCode != that.areaCode) return false;
//        if (prefix != that.prefix) return false;
//        return lineNumber == that.lineNumber;
//    }

    @Override
    public int hashCode() {
        int result = areaCode;
        result = 31 * result + prefix;
        result = 31 * result + lineNumber;
        return result;
    }

    public static void main(String[] args){
        Map<PhoneNumber,String> phoneNumberStringMap = new HashMap<PhoneNumber,String>();
        phoneNumberStringMap.put(new PhoneNumber(123, 456, 7890), "honghailiang");
        System.out.println(phoneNumberStringMap.get(new PhoneNumber(123, 456, 7890)));
    }
}
上述结果均为null;

题外话Java中的基本类型可以作为key值,包括String类,String类已经覆盖了equals方法和hashCode方法。
??
??

【Java实战】源码解析为什么覆盖equals方法时总要覆盖hashCode方法

标签:bucket   param   条件   main   class   默认   ble   替换   line   

原文地址:http://blog.csdn.net/honghailiang888/article/details/71711454

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!