java基础-HashMap

jdk7的HashMap实现的思路比较简单，就是一个Entry数组，数组中每个Entry都是一个链表的起点（表头）。

 

    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        //如果key为null，则将该entry放在第0位
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        //检查第i位的链表中是否存在该key，如果存在，则将原value替换为新value
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                //并返回旧value
                return oldValue;
            }
        }

        modCount++;
        //如果不存在则将entry添加在第i位链表表头，如果(size >= threshold) && (null != table[bucketIndex])为真（threshold=capacity*loadFactor），还会涉及resize（扩容，resize(2 * table.length);）操作
        addEntry(hash, key, value, i);
        return null;
    }

 jdk7的hash函数

    final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

 

jdk7中的HashMap存在一个问题，如果key的hash值都映射到同一个桶中，hashMap的查找就会退化成顺序查找，这会极大影响查找性能（对插入性能无影响）。jdk8为了解决这一问题，对HashMap进行了一些改进，当一个桶中的链表长度大于内设阈值（8）时，就会将该桶的链表树化（treeify），即将链表转变为一个红黑树（其余位置的链表不会受到影响）。

 

 

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

 jdk8的hash函数

    static final int hash(Object key) {
        int h;
        //hashCode返回一个int共32位，最终就是高16位保持原样，低16位与高16亦或后形成新的低16位。这样做是为了防止hashCode低位全0的情况，在映射后（hash&(table.length-1)）就会聚集在第0位。
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

 

 

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //tab就是table，p是前驱节点，n是table长，i是key的index
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //如果第i位尚没有节点，则直接插入
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {//第i位已经存在节点的情况
            Node<K,V> e; K k;
            //首节点的key与即将插入的key相同
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果首节点是TreeNode，说明该位是一棵红黑树，直接插入
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //遍历链表进行替换或插入
            else {
                for (int binCount = 0; ; ++binCount) {
                //如果p.next为null，则插入到链表末端
                if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //如果链表长度大于TREEIFY_THRESHOLD（8，不可设置）则树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);//树化该位的链表为一棵红黑树
                        break;
                    }
                    //如果找到相同的key，则直接跳出，后续会更新value
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //更新value
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }