HashMap要点记

HashMap要点

HashMap类结构：

public class HashMap<K,V>       extends AbstractMap<K,V>       implements Map<K,V>, Cloneable, Serializable

由此可见HashMap实现标记接口Cloneable用于表明HashMap对象会重写java.lang.Object#clone()方法，HashMap实现的是浅拷贝（shallow copy）。实现标记接口Serializable，用于表明HashMap对象可以被序列化。
HashMap继承自AbstractMap,AbstractMap对Map中的方法提供了一个基本实现，减少了实现Map接口的工作量。

设计理念：
HashMap是一种基于哈希表（hash table）实现的map，哈希表（也叫关联数组）一种通用的数据结构，key经过hash函数作用后得到一个槽（buckets或slots）的索引（index），槽中保存着我们想要获取的值。如图：

一些不同的key经过同一hash函数后可能产生相同的索引，也就产生了冲突，所以，我们使用HashMap来是实现具体类时，需要设计个好的hash函数，使冲突尽可能的减少，其次是需要解决发生冲突后如何处理。

HashMap特点：

• 线程非安全，并且允许key与value都为null值，HashTable与之相反，为线程安全，key与value都不允许null值。
• 不保证其内部元素的顺序，而且随着时间的推移，同一元素的位置也可能改变（resize的情况）。
• put、get操作的时间复杂度为O(1)。
• 遍历其集合视角的时间复杂度与其容量（capacity，槽的个数）和现有元素的大小（entry的个数）成正比，所以如果遍历的性能要求很高，不要把capactiy设置的过高或把平衡因子（load factor，当entry数大于capacity*loadFactor时，会进行resize，reside会导致key进行rehash）设置的过低。
• 由于HashMap是线程非安全的，这也就是意味着如果多个线程同时对一hashmap的集合试图做迭代时有结构的上改变（添加、删除entry，只改变entry的value的值不算结构改变），那么会报ConcurrentModificationException，专业术语叫fail-fast，尽早报错对于多线程程序来说是很有必要的。
• Map m = Collections.synchronizedMap(new HashMap(…)); 通过这种方式可以得到一个线程安全的map。

HashMap实现原理：
HashMap其实也是一个线性的数组实现的,所以可以理解为其存储数据的容器就是一个线性数组。首先HashMap里面实现一个静态内部类Entry，其重要的属性有 key , value, next，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。

transient HashMapEntry<K, V>[] table;

存取实现：

// 存储时:int hash = key.hashCode(); // 这个hashCode方法不详述,只要理解每个key的hash是一个固定的int值int index = hash % Entry[].length;Entry[index] = value;// 取值时:int hash = key.hashCode();int index = hash % Entry[].length;return Entry[index];

在存储的时候 hash值有可能一样，这时候怎么办勒？这里HashMap里面用到链式数据结构的一个概念，这个时候Entry的next属性就派上用场了。例如，键值对A的hash为0，Entry[0] = A，然后，B进来了，B的hash值也等于0，那么，B.next = A，Entry[0] = B，如果又进来C,index也等于0，那么C.next = B，Entry[0] = C，这样我们发现index=0的地方其实存取了A,B,C三个键值对，他们通过next这个属性链接在一起。也就是说数组中存储的是最后插入的元素。

public V put(K key, V value) {    if (table == EMPTY_TABLE) {        inflateTable(threshold);    }    if (key == null)        return putForNullKey(value); //null总是放在数组的第一个链表中    int hash = hash(key);    int i = indexFor(hash, table.length);    //这里的循环是关键    //当新增的key所对应的索引i，对应table[i]中已经有值时，进入循环体    for (Entry<K,V> e = table[i]; e != null; e = e.next) {        Object k;        //判断是否存在本次插入的key，如果存在用本次的value替换之前oldValue，相当于update操作        //并返回之前的oldValue        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {            V oldValue = e.value;            e.value = value;            e.recordAccess(this);            return oldValue;        }    }    //如果本次新增key之前不存在于HashMap中，modCount加1，说明结构改变了    modCount++;    addEntry(hash, key, value, i);    return null;}void addEntry(int hash, K key, V value, int bucketIndex) {    //如果增加一个元素会后，HashMap的大小超过阈值，需要resize    if ((size >= threshold) && (null != table[bucketIndex])) {        //增加的幅度是之前的1倍        resize(2 * table.length);        hash = (null != key) ? hash(key) : 0;        bucketIndex = indexFor(hash, table.length);    }    createEntry(hash, key, value, bucketIndex);}void createEntry(int hash, K key, V value, int bucketIndex) {    //首先得到该索引处的冲突链Entries，第一次插入bucketIndex位置时冲突链为null，也就是e为null    Entry<K,V> e = table[bucketIndex];    //然后把新的Entry添加到冲突链的开头，也就是说，后插入的反而在前面（第一次还真没看明白）    //table[bucketIndex]为新加入的Entry，是bucketIndex位置的冲突链的第一个元素    table[bucketIndex] = new Entry<>(hash, key, value, e);    size++;}/*当哈希表的容量超过默认容量时，必须调整table的大小。当容量已经达到最大可能值时，那么该方法就将容量调整到Integer.MAX_VALUE返回，这时，需要创建一张新表，将原表的映射到新表中。*/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];    //initHashSeedAsNeeded(newCapacity)的返回值决定了是否需要重新计算Entry的hash值    transfer(newTable, initHashSeedAsNeeded(newCapacity));    table = newTable;    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);}/** * Transfers all entries from current table to newTable. */void transfer(Entry[] newTable, boolean rehash) {    int newCapacity = newTable.length;    //遍历当前的table，将里面的元素添加到新的newTable中    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];            //最后这两句用了与put放过相同的技巧            //将后插入的反而在前面            newTable[i] = e;            e = next;        }    }}

Entry[]的长度一定后，随着map里面数据的越来越长，HashMap里面设置一个因子，随着map的size越来越大，Entry[]会以一定的规则加长长度。

HashMap的get方法：

public V get(Object key) {    //单独处理key为null的情况 null key总是存放在Entry[]数组的第一个元素。    if (key == null)        return getForNullKey();    Entry<K,V> entry = getEntry(key);    return null == entry ? null : entry.getValue();}private V getForNullKey() {    if (size == 0) {        return null;    }    //key为null的Entry用于放在table[0]中，但是在table[0]冲突链中的Entry的key不一定为null    //所以需要遍历冲突链，查找key是否存在    for (Entry<K,V> e = table[0]; e != null; e = e.next) {        if (e.key == null)            return e.value;    }    return null;}final Entry<K,V> getEntry(Object key) {    if (size == 0) {        return null;    }    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;}

HashMap的remove操作：

public V remove(Object key) {    Entry<K,V> e = removeEntryForKey(key);    //可以看到删除的key如果存在，就返回其所对应的value    return (e == null ? null : e.value);}final Entry<K,V> removeEntryForKey(Object key) {    if (size == 0) {        return null;    }    int hash = (key == null) ? 0 : hash(key);    int i = indexFor(hash, table.length);    //这里用了两个Entry对象，相当于两个指针，为的是防治冲突链表发生断裂的情况    //这里的思路就是一般的单向链表的删除思路    Entry<K,V> prev = table[i];    Entry<K,V> e = prev;    //当table[i]中存在冲突链表时，开始遍历里面的元素    while (e != null) {        Entry<K,V> next = e.next;        Object k;        if (e.hash == hash &&            ((k = e.key) == key || (key != null && key.equals(k)))) {            modCount++;            size--;            if (prev == e) //当冲突链表只有一个Entry时                table[i] = next;            else                prev.next = next;            e.recordRemoval(this);            return e;        }        prev = e;        e = next;    }    return e;}

HashMap确定数组index：hashcode % table.length取模，按位取并，作用上相当于取模mod或者取余%。这意味着数组下标相同，并不表示hashCode相同。

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

HashMap的初始大小：

 public HashMap(int initialCapacity, float loadFactor) {        .....        // 注意table初始大小并不是构造函数中的initialCapacity，而是 >= initialCapacity的2的n次幂！！！！        int capacity = 1;        while (capacity < initialCapacity)            capacity <<= 1;        this.loadFactor = loadFactor;        threshold = (int)(capacity * loadFactor);        table = new Entry[capacity];        init();    }