jdk：HashMap

首先看我们通常使用的HashMap构造函数：

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

方法init()是一个空方法，方法注释的第一句是“Initialization hook for subclasses.”，应该是跟子类交互的一个方法，既然是空方法，这里暂且不关注。
整个方法其实就只有一个作用table = new Entry[DEFAULT_INITIAL_CAPACITY];
就是用默认的参数初始化了一个Entry类型的数组，table是HashMap的一个成员变量transient Entry[] table;

从这里基本得出结论HashMap的结构基础是一个数组，既然它是Entry类型的，来看一下Entry的定义:

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

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
        V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /**
         * This method is invoked whenever the value in an entry is
         * overwritten by an invocation of put(k,v) for a key k that's already
         * in the HashMap.
         */
        void recordAccess(HashMap<K,V> m) {
        }

        /**
         * This method is invoked whenever the entry is
         * removed from the table.
         */
        void recordRemoval(HashMap<K,V> m) {
        }
    }

大概可以看得出它有一个key和一个value，原来它就是键值对的容器，另外它还有一个指向自身类型的引用next，这似乎又跟链表扯上了关系。

到现在一切都还不清晰，知道数据基础是数组，又可能跟链表有关系。
理一下思路，目的是看数据结构，那看哪个方法可以窥探到数据结构呢？很显然 put(K key, V value)

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

可以看到 方法通过键的hashCode()方法经过hash() indexFor()两个方法的转换得到了一个数组的索引i，通过下面的table[i]可以看出来，hash()，indexFor()方法如下：

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

/**
     * Returns index for hash code h.
     */
static int indexFor(int h, int length) {
    return h & (length-1);
}

这两个方法看得出来是比较精妙的，但是对于理解HashMap数据结构可以不用关注，我们只要知道，通过键的hashCode()，经过这两个方法处理可以获取一个数组的位置索引。

再看put方法中的for循环，e被初始化为数组上索引位置的元素，然后通过e.next()遍历，循环体的意思大概就是如果遍历到的Entry的key与要放入的key相同的，就把它的value替换成要放入的value，从这里分析可以得出数组上的table[i]应该是一个单向Entry链表的头

还没有完，如果for循环中没有进入if语句，也就是说没有遍历到的Entry都不满足key与要放入的key相同，这时候会执行addEntry(hash, key, value, i);看一下这个方法：

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

Entry构造函数：
Entry(int h, K k, V v, Entry<K,V> n) {
     value = v;
     next = n;
     key = k;
     hash = h;
 }

看addEntry，先取出的数组索引位置的Entry，也就是table[i]，然后将要放入的key，value和这个table[i]，作为参数构造了一个Entry，赋给了table[i]，结果就是当前的table[i]存放了要放入的key和value，并且next指向了之前的table[i]。

想象一下从无到有的过程，很显然这就是一个链表，这样一来所有的猜想都被证实了，table[i]确实是一个链表的头，并且每当有新元素插入时候，这个位置都会被更新，原来的元素下移。

至此HashMap的数据结构已经清晰了，基础结构是一个数组，数组上的每一个位置又有一个链表，可以想象成葡萄架的形状。

HashMap的工作原理：
1 有hashCode可以通过static int hash(int h)、static int indexFor(int h, int length)定位到一个数组的索引位置，也就是一个链表的头。
2 在一个链表中，通过equals方法来判断是否是同一个key（上面的put(K key, V value)证实了这一点）。