Java HashMap&Hashtable 源代码分析

Java中List是使用数组来实现，这种实现方式有利于查找元素，但是在插入元素时非常复杂，因为需要移动其他元素，如果使用LinkList，这种方法查找很麻烦，需要遍历这个列表，但是插入却又很复杂。因此出现了HashMap的结构。这种结构使用LinkList来实现，但是定位下标时，用hash函数来实现，这样可以快速查找到需要的元素。还是从基本的字段看起。

static final int DEFAULT_INITIAL_CAPACITY = 16;
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
transient Entry[] table;
transient int size;
int threshold;
final float loadFactor;
transient int modCount;

这里有几个主要的字段，解释如下：
table是存放元素的key,value,hash,以及下一个元素的指针。
size是table中存放元素的数量。
threshold是一个阀值，当数组元素超过这个值时，数组长度会增加。
loadFactor是一个比值，叫加载因子。数组元素的数量和数组长度的比值。
最后一个modCount还是用于多线程检测。

构造函数如下：

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

这里这些值都有一个默认的设置。

来看一下添加元素的逻辑：

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值是否为null，如果是的话，则调用putForNullKey方法并返回。这个方法的逻辑如下：

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

从table[0]开始查找，查找的方式是通过调用下一个元素的指针来循环实现的。
如果找到table[0]这个列表中的元素有null的key值，则直接用新值来覆盖掉。
如果没有，则在table[0]中再添加一个元素。添加逻辑如下：

void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

这里会调用resize方法。这个方法的逻辑稍后讲解。先继续put方法讲解。现在把判断完key是否为null了。如果不是的话，则调用hash函数来计算key值的hash值。具体逻辑如下：

/**
     * Applies a supplemental hash function to a given hashCode, which
     * defends against poor quality hash functions.  This is critical
     * because HashMap uses power-of-two length hash tables, that
     * otherwise encounter collisions for hashCodes that do not differ
     * in lower bits. Note: Null keys always map to hash 0, thus index 0.
     */
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);
    }

这个方法传入了java对象hash方法计算之后的整数结果。计算完又返回一个整数。哈希的含义是将一个整数的二进制均匀分布到另外一个区间上。这样可以有效防止冲突。
上面一段注释非常重要，翻译如下：
提供了一个hash函数通过一个给定的hashcode值，这样做是为了防止一个低质量的hash方法，这个方法很关键，因为hashmap使用了2的整数倍长度的hash table，否则的话会zai hashcode值的低比特位上遇到hash冲突，备注：Null总是会被hash计算为0，也就是定位到table的第0个元素上。

接着下一步就来查找元素的下标了。

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

这个方法通过hash值来计算数组下标。这个和上面的hash函数也有一定关系，通过注释来解释的话。
找到数组下标后，取得数组元素，并遍历该数组元素上的linkedlist。如果该数组下标上的linkedlist中元素key值和需要添加元素的key值相同，则覆盖掉旧值。

如果这里没有冲突，那么会在数组中直接添加一个元素。每次添加都会调用检查数组元素的个数是否超过了threshold的值，如果超过了，则调整数组长度，每次加长1倍。看看resize逻辑：

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

这个逻辑就很清晰了，检查数组的长度是否等于最大的长度，如果是的话，则将threshold设置为整数最大值，直接返回。再下次添加元素的时候，程序执行到这里的时候，就不会继续往下执行了。
调整完长度以后，就把旧数组中的值全部迁移到新长度的数组中。逻辑如下：

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

这里需要注意一个地方就可以了。就是src[j] = null; 这里设置为null的目的也是为了GC进行垃圾回收。里面的do while语句主要用于解决冲突的情况。

删除元素的方法，也是使用了类似的原理来操作。hashmap是单线程的操作，不能在多线程的环境下使用。

Hashtable和hashmap的实现逻辑都一样，唯一不同是，hashtable的每一个接口都加锁了，因此在多线程环境中，可以使用hashtable，但是这样效率不高。因为多个线程只有一个可以访问hashtable的方法。如果需要提高效率在多线程环境中，可以使用ConcurrentHashMap对象，这个对象允许多个线程同时操作，其实现原理使用了分段锁技术。具体原理再分析ConcurrentHashMap对象时再说。