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-Vpublic 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进行分类，方便快速查找

六.思考点

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