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