HashMap源码分析

　　首先，HashMap 是 Map 的一个实现类，它代表的是一种键值对的数据存储形式。key和value允许为null,key不允许重复，可以接受null键和值。

　　jdk1.7中使用一个Entry数组来存储数据，jdk1.8中使用一个Node数组来存储数据，但这个Node可能是链表结构，也可能是红黑树结构。
　　jdk 8 之前，其内部是由数组+链表来实现的，继承了数组的线性查找和链表的寻址修改，而 jdk 8 对于链表长度超过 （底层代码>=）8 的链表将调用treeifyBin函数转储为红黑树。因为，如果按照链表的方式存储，随着节点的增加数据会越来越多，这会导致查询节点的时间复杂度会逐渐增加，平均时间复杂度Ｏ(n)。 为了提高查询效率，故在JDK１.8中引入了改进方法红黑树，以加快检索速度。此数据结构的平均查询效率为Ｏ(log n) 。

　　要了解红黑树，先要知道avl树，要知道avl树，首先要知道二叉树。

二叉树

　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树：

　　（1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

　　（2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

　　（3） 任意节点的左、右子树也分别为二叉查找树；

　　（4） 没有键值相等的节点。

　　二叉树就是每个父节点下面有零个一个或两个子节点。我们在向二叉树中存放数据的时候将比父节点大的数放在右节点，将比父节点小的数放在左节点，这样之后我们在查找某个数的时候只需要将其与父节点比较，大则进入右边并递归调用，小则进入左边递归。但其存在不足，如果运气很不好我的数据本身就是有序的，比如【1，2，3，4，5，6，7】，这样就会导致树的不平衡，二叉树就会退化成为链表。所以我们推出了avl树。

avl树

　　平衡二叉树又称AVL树，在满足二叉查找树特性的基础上，要求每个节点的左右子树的高度不能超过1　　

　　avl树即平衡树，他对二叉树做了改进，在我们每插入一个节点的时候，必须保证每个节点对应的左子树和右子树的树高度差不超过1。如果超过了就对其进行调平衡，具体的调平衡操作就不在这里讲了，无非就是四个操作——左旋，左旋再右旋，右旋再左旋。最终可以是二叉树左右两边的树高相近，这样我们在查找的时候就可以按照二分查找来检索，也不会出现退化成链表的情况。

　　那么平衡二叉树如何保持”平衡“呢？根据定义，有两个重点，一是左右两子树的高度差的绝对值不能超过1，二是左右两子树也是一颗平衡二叉树

　　二叉树和avl树详细讲解查看文章：二叉查找树和平衡二叉树

　　红黑树详细讲解查看文章：最容易懂得红黑树 

　　平衡二叉树是一棵高度平衡的二叉树，所以查询的时间复杂度是 O(logN) 。插入的话，失衡的情况有4种，左左，左右，右左，右右，即一旦插入新节点导致失衡需要调整，最多也只要旋转2次，所以，插入复杂度是 O(1) ，但是平衡二叉树也不是完美的，也有缺点，从上面删除处理思路中也可以看到，就是删除节点时有可能因为失衡，导致需要从删除节点的父节点开始，不断的回溯到根节点，如果这棵平衡二叉树很高的话，那中间就要判断很多个节点。所以后来也出现了综合性能比其更好的树—-红黑树，后面再讲。

红黑树

　　红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。

　　红黑树的特点：

　　　　1.节点是红色或黑色。
　　　　2.根节点是黑色。
　　　　3 每个叶子节点（NIL）是黑色。[注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
　　　　4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
　　　　5.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

　　之所以选择红黑树是为了解决二叉查找树的缺陷，二叉查找树在特殊情况下会变成一条线性结构（这就跟原来使用链表结构一样了，造成很深的问题），遍历查找会非常慢。
而红黑树在插入新数据后可能需要通过左旋，右旋、变色这些操作来保持平衡，引入红黑树就是为了查找数据快，解决链表查询深度的问题，我们知道红黑树属于平衡二叉树，但是为了保持“平衡”是需要付出代价的，但是该代价所损耗的资源要比遍历线性链表要少，所以当长度大于8的时候，会使用红黑树，如果链表长度很短的话，根本不需要引入红黑树，引入反而会慢。

　

HashMap的 get(Object key)方法分析(以下源码版本为jdk1.8版本)：

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

　　看下hash(key)算法：

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

　　hash方法计算的值为key的hashCode值与其右移16位后的异或的结果。

　　getNode源码：

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        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;
    }

　　Node<K,V>就是数组中存储的元素，其源码：

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

　　由以上代码我们可以看到，在HashMap中要找到某个元素，先根据hash(key)值来找到key对应的Node元素在数组中的位置，返回唯一的node.value。查找方式：

　　1.根据key的hash算法找到该key对应的Node在数组中的元素位置，找不到直接返回null;
　　2.可以找到元素位置，则根据key的equals方法匹配元素位置的key:
　　　　a.若相等则直接返回数组中的该元素的value值;
　　　　b.不相等则判断：该节点若属于红黑树则调用红黑树的方法查找并返回结果，否则用do{}while方式遍历链表查找；

HashMap的put(K key, V value)方法分析：　　

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;
    //如果 table 还未被初始化，那么初始化它
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //根据键的 hash 值找到该键对应到数组中存储的索引
    //如果为 null，那么说明此索引位置并没有被占用
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    //不为 null，说明此处已经被占用，只需要将构建一个节点插入到这个链表的尾部即可
    else {
        Node<K,V> e; K k;
        //当前结点和将要插入的结点的 hash 和 key 相同，说明这是一次修改操作
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //如果 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);
                    //当binCount为7的时候，循环了8次，满足此条件，此时链表长度为P头结点+7=8，也就是说当链表长度>8的时候 ，将链表裂变成红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                //遍历的过程中，如果发现与某个结点的 hash和key，这依然是一次修改操作
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //e 不是 null，说明当前的 put 操作是一次修改操作并且e指向的就是需要被修改的结点
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //如果添加后，数组容量达到阈值，进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

 

HashMap 碰撞问题处理：

　　碰撞：所谓“碰撞”就上面所述是多个元素计算得出相同的hashCode，在put时出现冲突。HashMap解决碰撞如下：

　　当程序试图将一个key-value对放入HashMap中时，程序首先根据hash(key)返回值决定该 Node(HashMap内部类Node实现了Entry) 的存储位置：

　　　　1.如果两个 Node的 key 的 hashCode() 返回值相同，那它们的存储位置相同。
　　　　2.如果这两个 Node的 key 通过 equals 比较返回 true，则新添加 Node的 value 将覆盖集合中原有 Node的 value，但key不会覆盖。
　　　　3.如果这两个 Node的 key 通过 equals 比较返回 false，则新添加的 Node将与集合中原有 Node形成 链表，而且新添加的 Node位于 Entry 链的尾部，当链表长度大于等于8，则将链表裂变成红黑树。

　　当HashMap中的数据越来越多时，发生碰撞的概率也越来越高，这个时候会对数据进行扩容，默认长度为16，负载因子为0.75，也就是数据数目达到两者乘积也就是16*0.75=12时，数组会扩容为原来的两倍，2*16=32。这个扩容操作叫做rehash，因为要对原先所有数据重新计算位置，再放入扩容后的数组中，所以如果可以确定数组长度的话，提前设置好长度，可以减少性能消耗。