HashMap源码浅析

HashMap
参考：http://blog.youkuaiyun.com/jeffleo/article/details/54946424
http://blog.youkuaiyun.com/qq_27093465/article/details/52207135

1.HashMap的定义和构造函数
底层实现原理是：数组 + 链表 + 红黑树

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

HashMap继承自AbstractMap，AbstractMap是Map接口的骨干实现，AbstractMap中实现了Map中最重要最常用的方法，这样HashMap继承AbstractMap就不需要实现Map的所有方法了，让HashMap减少了大量的工作。这里实现Map接口，没有什么作用，应该是为了让Map的层次结构更加清晰。

2.HashMap的成员变量
默认初始化大小

  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
    加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    Node类型的数组，HashMap用这个来维护内部的数据结构，它的长度由容量决定
    transient Node<K,V>[] table;
    HashMap的大小
    transient int size;
    HashMap的极限容量，扩容临界点（容量*加载因子）
    int threshold;

3.HashMap的四个构造函数
3.1 构造一个具有默认初始容量（16）和默认加载因子（0.75）的空HashMap

 public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

3.2 构造一个带指定初始容量和默认加载因子（0.75）的空HashMap   

 public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

3.3构造一个带指定初始容量和加载因子的空HashMap

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

3.4  构造一个映射关系与指定Map的相同的新HashMap  

 public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

容量：initialCapacity，哈希表中桶的数量，初始容量只是哈希表在创建时的容量，实际上就是Node<K,V>[] table的容量。
加载因子：loadFactor。在哈希表在其容量自动增加之前可以达到多满的一种尺度。它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之越小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对控件的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对控件造成严重浪费。系统默认负载因子为0.75，一般情况下是无需修改的。

当哈希表中的条目数超出了加载因子与当前容积的乘积时，则要对哈希表进行refresh操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

4.HashMap的数据结构
HashMap是一个“链表散列”，数据结构如下所示：

说明：上图中的Entry<K,V>实际上应该是Node<K,V>。

HashMap的构造函数的源码：

 public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0) //容量不能小于0
            throw new IllegalArgumentException("Illegal initial capacity: " +
                initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY) //容量不能超出最大容量
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) //加载因子不能小于等于0 或者 为非数字
            throw new IllegalArgumentException("Illegal load factor: " +
                loadFactor);
        this.loadFactor = loadFactor; //设置加载因子
        this.threshold = tableSizeFor(initialCapacity);//设置容量大小
    }

//计算大于初始容量的最小的2次方作为哈希表table的长度，其中|是或运算，>>> 是无符号右移

static final int tableSizeFor(int cap) {
            int n = cap - 1;
            n |= n >>> 1;
            n |= n >>> 2;
            n |= n >>> 4;
            n |= n >>> 8;
            n |= n >>> 16;
            return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

方法的运行结果：cap为21，结果为32.
这样计算hash值的目的是为了让hash发生碰撞的概率比较小，这样就会使得数据在table数组中分布比较均匀，查询速度比较快。


在HashMap内部还有一个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);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

说明：Node类实现了Map.Entry接口，是HashMap的内部类，也是维护着一个key-value映射关系，除了key和value，还有next引用（该引用指向当前table位置的链表），hash值用来确定每一个Node链表在table中的位置。

5.HashMap的存储实现put(K,V) 解决冲突使用的是链地址法

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

//根据key获取对应的hash值，如果key为空，得到的就是0；如果不为空，就得到的是key的hash值的h右移16位次方
//所以这里可以得到，当输入的key为null的时候，插入的都是数组第一个位置，也就是Node

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

//参数说明：hash：key的hash值；key：传入的key；value：传入的value；
//onlyIfAbsent：如果为真，不改变存在的值；evict：如果为false，表格处于创建模式。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
  //tab是存储Node数组的，p是存储hash值对应的Node数组位置的头节点，n是存储数组的长度，i是hash对应的位置
    Node<K,V>[] tab; Node<K,V> p; int n, i; 
    if ((tab = table) == null || (n = tab.length) == 0) //如果table为空或者长度为0，就重新设置表
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null) //如果hash值所在的位置为空
        tab[i] = newNode(hash, key, value, null);//新增节点，并放入table中
    else {    //hash值所在的位置不为空，就添加到链表的前面
        Node<K,V> e; K k; 
        if (p.hash == hash &&  //判断p位置的第一个节点key是否和传入的key相同
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;  //相同就把p赋值给e
        else if (p instanceof TreeNode)  //判断p是否是红黑树节点
            //将新的key-value添加进入红黑树中
            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); //直接新增节点放在p的后面
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash); //替换在hash位置的链表中所有连接的节点
                    break;
                }
                if (e.hash == hash &&   //当前节点的key就是待存入的key
                    ((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; //将value值写入节点中
            afterNodeAccess(e); //一个回调方法
            return oldValue; //返回最初的值
        }
    }
    ++modCount; //该HashMap被修改的次数加1
    if (++size > threshold) //如果map中有的key-value的对数大于容量*加载因子，就重新设置map集合
        resize();
    afterNodeInsertion(evict); //一个回调方法，节点插入之后的回调
    return null;
}

//将key-value放入hashmap中，是putval的tree版本
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                               int h, K k, V v) {
    Class<?> kc = null;
    boolean searched = false;
    TreeNode<K,V> root = (parent != null) ? root() : this; //获取根节点
    for (TreeNode<K,V> p = root;;) {  //指向根节点
        int dir, ph; K pk;
        if ((ph = p.hash) > h)   //根节点的hash值大于待存入的hash值
            dir = -1;  
        else if (ph < h)  //根节点的hash值小于待存入的hash值
            dir = 1;
        else if ((pk = p.key) == k || (k != null && k.equals(pk))) //查找到节点，直接返回
            return p;
        else if ((kc == null &&  
                  (kc = comparableClassFor(k)) == null) ||
                 (dir = compareComparables(kc, k, pk)) == 0) {
            if (!searched) {  //未找到
                TreeNode<K,V> q, ch;  //ch存储p个左节点，q存储给定的key-value在p中的开始节点
                searched = true;
                //在p的左边或者右边找到给定的key-value节点，直接返回找到的节点q
                if (((ch = p.left) != null &&  
                     (q = ch.find(h, k, kc)) != null) ||
                    ((ch = p.right) != null &&
                     (q = ch.find(h, k, kc)) != null))
                    return q;
            }
            dir = tieBreakOrder(k, pk);
        }

        TreeNode<K,V> xp = p; 
        //判断给定的hash应该放在左边还是右边，如果根节点hash值大，也就是dir<0,就将传入的key-value放在左边，
        //否则放在右边.总之是升序排列
        if ((p = (dir <= 0) ? p.left : p.right) == null) { 
            Node<K,V> xpn = xp.next;
            TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn); //新的节点
            if (dir <= 0) //放在根节点的左边
                xp.left = x;
            else
                xp.right = x;
            xp.next = x;     //将x放在根节点的下一个节点，即链表的头结点处
            x.parent = x.prev = xp;  
            if (xpn != null)
                ((TreeNode<K,V>)xpn).prev = x;
            moveRootToFront(tab, balanceInsertion(root, x));//确保给定的根节点是链表的第一个节点
            return null;
        }
    }
}
//建立一个新的节点
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
    return new Node<>(hash, key, value, next);
}
//树节点的静态内部类
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // red-black tree links //红黑树
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node<K,V> next) {
        super(hash, key, val, next);
    }

    /**
     * Returns root of tree containing this node.
     */
    final TreeNode<K,V> root() {
        for (TreeNode<K,V> r = this, p;;) {
            if ((p = r.parent) == null)
                return r;
            r = p;
        }
    }
}

/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) //判断链表长度
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) { 
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}


// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }

/**
* Returns root of tree containing this node.
*/
final TreeNode<K,V> root() {
    for (TreeNode<K,V> r = this, p;;) {
        if ((p = r.parent) == null)
            return r;
        r = p;
    }
}

6.HashMap的获取实现get(Object key)

public V get(Object key) {
    Node<K,V> e;
    //首先 e = getNode(hash(key), key)找到对应key的节点，然后如果为null，就返回null，找到节点就返回对应的value
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    //判断table是否存有数据 
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node，总是检查第一个节点
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first; //如果第一个节点是需要的节点，直接返回
        if ((e = first.next) != null) { //第一个节点存在后续节点
            if (first instanceof TreeNode) //如果后续节点是树节点
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);//通过树的特有查找方法查找对应的节点
            do {  //如果不是树节点，直接遍历整个链表，查找对应的节点，找到就返回
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null; //一直未找到，直接返回null
}

final TreeNode<K,V> getTreeNode(int h, Object k) {
    return ((parent != null) ? root() : this).find(h, k, null);
}

7.Fail-Fast机制：
HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓Fail-Fast策略。
通过源码中的 modCount域实现，modCount记录修改次数，对HashMap内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount。

abstract class HashIterator {
    Node<K,V> next;        // next entry to return
    Node<K,V> current;     // current entry
    int expectedModCount;  // for fast-fail ，实现了Fast-Fail机制
    int index;             // current slot

    HashIterator() {
        expectedModCount = modCount; 
        Node<K,V>[] t = table;
        current = next = null;
        index = 0;
        if (t != null && size > 0) { // advance to first entry
            do {} while (index < t.length && (next = t[index++]) == null);
        }
    }

    public final boolean hasNext() {
        return next != null;
    }

    final Node<K,V> nextNode() {
        Node<K,V>[] t;
        Node<K,V> e = next;
        //判断是否相等，如果不相等就说明在迭代过程中有其他线程对数据进行了修改，直接抛出异常。
        //所以modCount也要声明为volatile，保证线程之间修改的可见性
        if (modCount != expectedModCount) 
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        if ((next = (current = e).next) == null && (t = table) != null) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
        return e;
    }

    public final void remove() {
        Node<K,V> p = current;
        if (p == null)
            throw new IllegalStateException();
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        current = null;
        K key = p.key;
        removeNode(hash(key), key, null, false, false);
        expectedModCount = modCount;
    }
}

**

##总结：

由所有HashMap类的“Collection视图方法”所返回的迭代器都是快速失败的： 在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的remove方法，其他任何时间任何方式的修改，迭代器都将抛出ConcurrentModificationException。

因此，面对并发的修改，迭代器很快就会完全失败，而不冒在将来不确定的时候发生任意不确定行为的冒险。 但是，迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。 快速失败迭代器尽最大努力抛出ConcurrentModificationException。

因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

**