【Java】HashMap 实现原理

Java集合框架有两个顶级接口，一个是collection接口，另一个是map接口，hashmap便是map接口的重要实现类。首先看map接口。根据map键值对的特性，接口中必然有相关的方法，主要是：

V get(Object key);
V put(K key, V value);
V remove(Object key);
Set<K> keySet();
Collection<V> values();
Set<Map.Entry<K, V>> entrySet();

前三个与map的操作有关，后三个与map遍历相关。

在map接口中，还定义了一个entry接口，hashmap实现本质上是一个entry的数组的链表。所以entry可以看成是hashmap的基本单元。下面是entry接口的内容，其中最核心的其实就是这三个方法：

K getKey();
V getValue();
V setValue(V value);

是对一个entry的key和value的获取以及value的修改。

下面是hashmap的实现类：

首先看一下重要的成员变量，

static final int DEFAULT_INITIAL_CAPACITY = 16; 
static final float DEFAULT_LOAD_FACTOR = 0.75f;
transient Entry<K,V>[] table;
int threshold;
final float loadFactor;
transient int modCount;

再看一下构造函数：

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        init(); }

initialCapacity是一个与hashmap大小相关的参数，但是呢，他并不是最终的大小，可以看到，数组的大小其实是capacity，capacity是一个大于等于initialCapacity的2的次方，这个是通过一个while循环计算得到的，为什么必须是2的次方后面会说。loadfactor是装载因子，衡量饱满度。threashold是一个阈值，如果大于这个值，就认为hashmap太满了，碰撞的概率就很大，这时会触发resize过程，让hashmap扩容。modcount与多线程的迭代相关。table是entry的数组。

与hash有关的方法：

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

        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);
    }

上述方法用于计算hash值，首先得到key的hashCode，然后再位运算，最终的hash值很均匀，原因不详。

    static int indexFor(int h, int length) {
        return h & (length-1);
    }

这个函数用上面得到的hash值计算table的索引，为了让每一个位置都有可能容纳一个entry，我们第一个想到是的是除模运算，但是在计算机中除法的效率很低，这里使用位运算就大大提高了效率，这里也解释了为什么数组大小是2的次方，因为2的次方减去1以后就是一个全1的二进制数，做and操作就会保证索引的均匀性，否则加入某一位是0，那么这一位永远不会再索引中出现。这样就可以通过key定位table的索引了。

再看get方法：

    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

如果key是null，就调用如下方法：

    private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

key为null的entry存放在索引为0的位置，但是位置0不一定只有key为null的value，所以需要遍历位置0的所有entry，返回key为null的value。如果key不是null，那么就调用getEntry方法：

    final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

使用key定位索引，然后遍历索引里面的所有entry，找到key相等的value，返回，为什么要遍历，因为可能有碰撞。如果没指定key的entry，返回null。

下面是put方法：

    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        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为null的值，会调用如下方法：

    private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

从索引0的entry数组遍历，看是否已经存在，如果是就只是更改value，此时modecount不加，说明更新不会触发迭代异常，否则就调用addEntry方法，新增一个entry。

    void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }

增加一个entry需要看容量是否超过了阈值，如果超过，就需要resize扩容。然后调用createEntry新增一个entry。

    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

这里就是调用entry的构造函数，让新的entry成为这个table槽位的第一个entry，其next指针设置为原本的第一个entry，所以新的元素都是插入到队首的。

那如果key不是null，过程也类似，通过hash值定位索引，然后在对应的table槽位中遍历entry，更新或者添加。过程一样。

最后看下扩容：

    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];
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;
        transfer(newTable, rehash);
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

扩容会新建一个容量为原来2倍的table，然后调用下面的方法把原始的entry加入到新的table：

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

这个transfer过程就是把原本的每一个entry重新计算索引，再添加到队首的过程。

这边是hashmap的一些核心的实现。

最后，注意hashmap不是线程安全的，因为比方说某一时刻两个线程都要put相同的key和value，很可能在map里面存在两个一模一样的entry，两个都检测到没有key，就调用了addentry方法。

hashtable的实现基本上鱼hasnmap是一样的，只不过对一些方法加了synchroninzed锁，hashmap是一个hashtable的轻量级实现，在多线程环境下应该使用hashtable而非hashmap，当然也可以使用其他的线程安全级别的map，或者自己封装一下hashmap。hashtable还有一个却别就是不支持null的key和value。会报异常。