HashMap实现原理及实现解析

java中常用到HashMap，决定了解其实现原理。

1、存储结构

1.1、数组

存储空间连续，空间复杂度大，但查询时时间复杂度小，为O(1)。即寻址容易，插入、删除困难。

1.2、链表

存储空间可以不连续，空间复杂度小，但查询时间复杂度大，为O(n)。即插入、删除容易，寻址困难。

1.3、哈希表

将数组和链表结合，取长补短，产生一种寻址容易，插入删除也容易的数据结构。

 在HashMap中有静态内部类Entry，主要结构是key、value和next，形成一个链表结构。在HashMap中有定义 transient Entry[] table来存储Entry。这样HashMap用线性数组来存储数据，根据hash值来创建Entry链。

2、存取原理

 

2.1、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))) {//key相同时替换原来的value
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;//结构改变次数，与fail-fast机制有关
        addEntry(hash, key, value, i);//构造Entry并存储
        return null;
    }

 

 void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry<K,V> e = table[bucketIndex];//取出原来存储在bucketIndex位置的Entry e
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);//创建新的Entry，并将next设置为e
        if (size++ >= threshold)//当前数量达到需要扩容的门槛
            resize(2 * table.length);//重新计算容量
    }

 

 

2.2、get

 

 public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());//计算用来计算存储位置的值
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {//获取目标Entry的位置Entry链，并遍历改Entry链查找目标Entry
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;//找到目标返回
        }
        return null;
    }

 

 

2.3、remove

 

public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);//删除对应的Entry
        return (e == null ? null : e.value);//返回对应Entry的Value
    }

final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];//找到对应Entry的存储链上的第一Entry
        Entry<K,V> e = prev;//e表示当前Entry

        while (e != null) {
            Entry<K,V> next = e.next;//找到e的下一个Entry标记为next
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {//发现e是要删除的Entry
                modCount++;//标记结构改变次数
                size--;//容量减一
                if (prev == e)//e是前一个Entry
                    table[i] = next;
                else
                    prev.next = next;//前一个Entry的next设为next
                e.recordRemoval(this);
                return e;//返回被删除的Entry
            }
            prev = e;//当前的Entry变成前一个Entry
            e = next;//下一个Entry变成当前的，继续判断e是否是要被删除的Entry
        }

        return e;
    }

 

3、rehash过程

 

 void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {//原数组容量已达到可用容量的上限
            threshold = Integer.MAX_VALUE;//阈值设为最大的int
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);//将原来的数组中的内容重新计算放在新的数组
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);//重新设置阈值,loadFactor默认是0.75，一般不需要改变
    }

 void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

 所以，如果事先知道要存储数量的大小，可预先设置好容器的大小（默认是16），减少resize的调用，以提高速度。