HashMap结构,原理

一.HashMap容器概念

容器存储结构：Entry[] table

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

容器大小：容器默认可以存放16个K-V元素；也可以自己指定容器大小；容器的大小始终为2的n次方,

数组的索引：key的hashcode * table.length

容器扩容阀值：threshold = table.length * 0.75 

容器扩容大小：table.size * 2

二.HashMap.put

分析HashMap.put(K,V)方法：

1.计算Key的hash值

2.根据容器大小和key的hashcode值计算table的索引index（hash & (length-1);）

3.table[index]=value存放

    hash值不相同：保存在table[index]=value位置

    hash值相同：进行equals比较：相同进行替换；不相同，链表方式新增；

4.如果table.size > table.length * 0.75 进行rehash，扩容；

所以：对象重写了equals方法，必须同时重写hashcode，为什么呢？

1.首先必须清楚object中的equals是比较内存地址，如果内存地址相等，则认为是2个相同的对象。

2.如果一个新的对象重写equals，则要求hashcode的计算规则要和equals的判断对象是否相同的逻辑保持一致，比如equals比较对象中的name属性，name相同认为对象相同，则此时hashcode的计算方式也必须用到name属性来计算hash，如果不重写，往hashmap这样的容器中存放会将相同的对象存在在不同的table中，因为不重写带来hashcode值可能不相同

三.HashMap的扩容

请看下面2段代码

//测试类
public class HashMapTest {

    public static void main(String[] args) {
        Map<Value, String> map = new HashMap<Value, String>(2);//初始容量2
        Map<Value, String> map = new HashMap<Value, String>(3);//初始容量4
        Map<Value, String> map = new HashMap<Value, String>();//初始容量16
        map.put(new Value("3"), "3");
        System.out.println(map);
        map.put(new Value("7"), "7");
        System.out.println(map);
        map.put(new Value("5"), "5");
        System.out.println(map);
        map.put(new Value("9"), "9");
        System.out.println(map);
    }
}

//存放于HashMap中的K-V
public class Value {

    private String value;

    public Value(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public int hashCode() {
        return 1;//注意这里重写了
    }

    @Override
    public String toString() {
        return value;//注册这里重写了
    }

}

往HashMap中顺序存放3，7，5，9，如果初始容量大小不同，最终的结果是不同的，请看每种容量下的运行结果

1.初始容量为2，最终运行结果

Map<Value, String> map = new HashMap<Value, String>(2);//初始容量2，threshold = 1

这里运行的结果为：7，3，5，9，在put(5,5)后进行了扩容，table长度为4，在put(9,9)又一次扩容，table的长度为8

2.初始容量为3，最终运行结果

Map<Value, String> map = new HashMap<Value, String>(3);//初始容量4，threshold = 3

这里运行的结果为：3，7，5，9，进行了扩容，扩容后table的长度为8

3.初始容量为16，最终运行结果

Map<Value, String> map = new HashMap<Value, String>();//初始容量16，threshold = 12

这里运行的结果为：9，5，7，3，进行进行扩容，table的长度为16

------------------------------------------为什么呢？------------------------------------------

下面看下HashMap中的put方法

    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        //计算hash值，并通过hash和table.length -1进行索引的计算
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        //对key进行hash和equals比较，若存在，进行value替换
        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++;
        //该key不存在，新增Entry
        addEntry(hash, key, value, i);
        return null;
    }

新增entry

    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);//把原先的e作为当前e的next值
        //查看当前的size是否超过了设定的阈值threshold，如果超过，需要扩容，注意这里进行了size++
        if (size++ >= threshold)
            resize(2 * table.length);
    }

将老的table迁移到新的table上

    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        //创建新的Entry[]
        Entry[] newTable = new Entry[newCapacity];
        //rehash，将oldTable迁移到newTable
        transfer(newTable);
        table = newTable;
        //计算新的扩容阀值
        threshold = (int)(newCapacity * loadFactor);
    }

//rehash过程，将原先链表尾部的元素移动到newTable链表头部

    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        //以new HashMap(2)来说，依次put(3,3）,put(7,7)后，oldTable中的结构为7，next指向3
        for (int j = 0; j < src.length; j++) {
            //e对应的Entry对象key=7，value=7,next=3（Entry的key=3，value=3,next=null）
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    //next=3（Entry的key=3，value=3,next=null）
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];//第1次遍历(e=7),next执行null，因为newTable[i]=null),第2次遍历（e=3），next指向newTable[i]已经存在的entry，也就是7
                    newTable[i] = e;//设置newTable[i] = 7
                    e = next;//下次遍历从当前e指向的next=3开始，所以这里可以看出，原先链表尾部的变成了链表头部
                } while (e != null);
            }
        }
    }

------------------------------------------------------------------------------

从源代码分析来看：

HashMap map = new HashMap(2),依次put(3,3),put(7,7),put(5,5),put(9,9)

经历第1次扩容后顺序变为3，7

经历第2次扩容后顺序变为7，3，5，9

------------------------------------------------------------------------------

四.HashMap死循环

产生的原因是：d多线程并发put时，形成了环形链表，引起死循环，分析如下

新建Map：HashMap map = new HashMap(8); 此时扩容的阀值threshod=6

线程1执行如下代码

map.put(new Value("1"), "1");
map.put(new Value("2"), "2");
map.put(new Value("3"), "3");
map.put(new Value("4"), "4");
map.put(new Value("5"), "5");
map.put(new Value("6"), "6");
map.put(new Value("7"), "7");

线程2执行如下代码

map.put(new Value("8"), "8");

在看rehash的代码

    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;//线程1挂起,开始切换线程2执行和扩容
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                } while (e != null);
            }
        }
    }

线程1在put(new Value("7"),"7")时进行扩容（因为size>thresold），扩容过程中在上面代码09行挂起，此时线程1的oldTable和newTable如下

线程2执行put(new Value("8","8")后，完成扩容，table.length=16,thresold=12，newTable如下

线程1唤醒继续扩容，此时线程2的newTable变成了table, 线程1扩容时将线程2的newTable移动倒线程1的newTable中

五.HashMap使用场景

适合于读多写少的场景，比如国家，地区列表的初始值可以放入全局的HashMap中，提高读取的速度

方法内部作临时转换用，比如按key进行分类，方便快速查找

六.思考点

为什么内部要用链表来实现呢？在来看下链表是啥回事