Java集合（一）HashMap

HashMap

特点： HashMap的key和value都允许为空，无序的，且非线程安全的

数据结构： HashMap底层是一个数组，数组的每一项又都是链表，即数据和链表的结合体。当新建一个HashMap对象时，就会初始化一个数组

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

HashMap的存储单元Entry里面存放键值，且它持有指向下一个元素的引用，从而构成了链表

HashMap的存储

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

put()方法的步骤：

1. 当key为空时，空的key会默认放在第零位的数组上
2. 拿到key的hash值，再调用hash()方法重新计算出一个hash值。根据JDK源码，调用hash()方法的目的是为了打乱原有的hash值，防止糟糕的hash算法

static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

　　3.  根据hash值对Entry数组取模获得到存放数据的位置。取模操作的正确性依赖于数组的长度必须是2的N次幂。所有，在HashMap的构造函数中，如果指定HashMap初始大小为initialCapacity，如果initialCapacity不是2的N次幂，HashMap会算出大于initialCapacity的最小2的N次幂，作为Entry数组的初始大小

static int indexFor(int h, int length) {
     return h & (length-1);
}

　　4.  判断是否存在相同的key，存在则将新的value存入，旧的返回，细节是先比较hash值，相同则再比较key，从而提高效率

　　5.  modCount++是用于fail-fast机制，每次修改HashMap的数据结构都会自增一次

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

　　6.  调用addEntry()方法。先设置一个变量e指向当前数组下标对象，再将键值放入新建的Entry对象里并将该对象赋给数组下标对象，且对象指向的下一个元素为旧的对象e。简单来说就是新建一个对象，将键值存入里面，并且将这个对象放在数组索引位置的第一个（即链头），它的下一个元素指向以前的第一个。

之后判断是否需要扩容，threshold为是否扩容的最大元素数目，当前HashMap的大小大于或等于该值时，就会进行扩容

threshold = (int)(capacity * loadFactor);

HashMap的读取

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    int hash = hash(key.hashCode());
    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.equals(k)))  
            return e.value;
    }
    return null;
}

简单来说就是通过key获取hash值，通过hash值获取数组下标，找到数组位置，将hash和key去比较是否相同

HashMap的删除

public V remove(Object key) {
    Entry<K,V> e = removeEntryForKey(key);
    return (e == null ? null : e.value);
}

final Entry<K,V> removeEntryForKey(Object key) {
    int hash = (key == null) ? 0 : hash(key.hashCode());
    int i = indexFor(hash, table.length);
    Entry<K,V> prev = table[i];
    Entry<K,V> e = prev;

    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)
                table[i] = next;
            else
                prev.next = next;
            e.recordRemoval(this);
            return e;
        }
        prev = e;
        e = next;
    }

    return e;
}

1. 通过key获取hash值，通过hash值获取数组下标，得到数组位置
2. 遍历链表，找到匹配的。当删除的是链头，将数组下标指向下一个，如果删除的不是链头，则将前一个对象的next指向被删除的后一个

Fail-Fast机制

HashMap是线程不安全的，所以当使用迭代器的过程中，有其他线程修改了map，则会抛出ConcurrentModificationException，这就是fail-fast策略

modCount为修改次数，当HashMap内容修改都将增加这个值，在迭代器迭初始化过程中会将这个值赋给expectedModCount，在迭代的过程中判断这两个值是否相等，不相等则表示被其他线程修改了Map

final Entry<K,V> nextEntry() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();

注意： modCount使用volatile修饰，保证线程之间修改的可见性

HashMap(jdk1.8)

jdk1.8版本的HashMap底层是由数组，链表和红黑树实现的。底层的内部类由Entry变成了Node

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

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }
        ......
}

hash()方法也变了，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低位都参与到Hash的计算中，同时不会有太大的开销。

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

put()方法

上传个网上的图片，put()方法的流程

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i; 8         if ((tab = table) == null || (n = tab.length) == 0)//步骤①
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)//步骤②
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&   //步骤③
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode) //步骤④
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {//步骤⑤
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)//步骤⑥
            resize();
        afterNodeInsertion(evict);
        return null;
    }

步骤：

1. 当tab数组为空或长度为0时，执行resize()方法扩容，进入下一步
2. 通过key计算hash值，得到数组索引，判断当该索引下的对象为空时，直接新建节点添加对象，跳到步骤⑥，否则进入步骤③
3. 判断该数组索引下的首个元素key是否一样，相同则直接覆盖value，否则进入步骤④
4. 判断该table[i]是否为treeNode，即是否为红黑树，如果是，直接插入键值对，不是则进入步骤⑤
5. 遍历table[i]，判断该链表长度是否大于等于8（bigCount从0开始），如果是则把链表转换为红黑树，在红黑树中进行插入操作，如果不是，则进行链表的插入操作
6. 判断实际容量是否大于threshold，是则扩容

扩容机制

jdk1.7中，进行扩容时，把旧数据放入到新数组中，链表的插入时，使用的是单链表的头插入方式，同一位置上的新元素总会被放到链头。在jdk1.8中，旧数组中一条链上的元素有可能被放到新数组的不同位置上

在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是JDK1.8不会倒置。

JDK1.7和JDK1.8的HashMap性能比较

HashMap中，如果key经过Hash算法得出的数组索引位置全部不相同，即Hash算法非常好，则getKey()方法的时间复杂度为O(1)。如果Hash算法极差，所有元素都在一个链表下或红黑树下，则时间复杂度为O(N)和O(lgN)。jdk1.8的总体性能优于jdk1.7。