HashMap、LinkedHashMap实现原理

看源码可以知道HashMap内部是由一个  Entry[] table组成

Entry的定义如下

 

 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;
}

 

 key、value

一个hash值，next指向下一个entry对象(后续会说为什么有这个next存在)；

 

HashMap的put方法实现

 

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        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);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

 

根据key对象的hashCode进行哈希，hash方法

 

static int hash(int h) {
        // 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);
    }

因此，不同key的hash值可能是相同的，所以需要存在next指针指向下一个对象，也就是说对于hash相同的对象，是以链表的形式存储的。

HashMap的实现结构图如下

 HashMap的使用建议

在使用HashMap时，最好显示声明HashMap的容量(initialCapacity)，以及负载因(loadFactor)

initialCapacity在HashMap初始化时确定数组的大小；

threhold=loadFactor*initialCapacity，确定数组何时扩充容量，扩充容量是现在数组大小的2倍；

 

initialCapacity 默认大小是16 

loadFactor是0.75

也就是说如果你按照以下方式一个HashMap

Map<K,V> map=new HashMap<K,V>();

当put的元素数目大于12的时候，可能就会导致HashMap需要扩容。扩容函数

 

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

 看上面代码，resize是新建一个大数组，把原有的数据的entry重新哈希放到新数组中，很是浪费资源。所以在使用HashMap时尽量指定初始化大小；

 

LinkedHashMap实现原理

 

LinkedHashMap继承在HashMap，其中对Entry<K,V>对象进行了扩展，定义如下：

private static class Entry<K,V> extends HashMap.Entry<K,V> {
        // These fields comprise the doubly linked list used for iteration.
        Entry<K,V> before, after;

	Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
            super(hash, key, value, next);
        }
}

 在原有HashMap.Entry<K,V>基础上加入了before、after两个指针，那么LinkedHashMap就变成了一个带有双向链表的数组；因此在Iterator时，LinkedHashMap的速度要高于HashMap，而且在Map的容量越大时，区别更明显；