【Java集合框架】——HashMap源码分析

HashMap源码分析（jdk1.8)

HashMap是一个数组+链表结构的存储结构。底层的数组作为哈希桶，通过计算存入数据的key值得哈希值
将数据存放到各个哈希桶中，当出现哈希值相同的情况，会用链表进行存储，链表中每个节点都是一个元
素。HashMap是线程不安全的。
jdk1.8 中，改良了一些算法以及数据结构实现，当一个桶中链表长度大于8时会转化为红黑树。Entry类也改为Node类，
区别是Node类有其导出类TreeNode类方便转换成红黑树。
也正是通过改良了HashMap的拉链法的数据结构，将获取一个对象所需要的次数时间复杂度从O（N/M)降低为O（log(N/M)).

哈希表：相比上述几种数据结构，在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)，接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。

我们知道，数据结构的物理存储结构只有两种：顺序存储结构和链式存储结构（像栈，队列，树，图等是从逻辑结构去抽象的，映射到内存中，也这两种物理组织形式），而在上面我们提到过，在数组中根据下标查找某个元素，一次定位就可以达到，哈希表利用了这种特性，哈希表的主干就是数组。

比如我们要新增或查找某个元素，我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。 存储位置 = f(关键字)

哈希冲突

然而万事无完美，如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap即是采用了链地址法，也就是数组+链表的方式，

桶中链表未转换为红黑树的结构图：

转化为红黑树的结构：

源码解析：

首先有几个重要的常量定义：

//默认初始容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4；//16
//最大桶容量
static final int MAXIMUM_CAPACITY = 1 << 30;// 2^30
//默认加载因子，用来计算哈希表元素数量阈值（threshold=哈希桶.length*Load_factor)
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//默认转化为树的阈值
static final int TREEIFY_THRESHOLD = 8;
//默认转化回链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//当桶中的bin被树化时最小的hash表容量
static final int MIN_TREEIFY_CAPACITY = 64;

核心函数：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;  //table即原散列表，当map初始化以后，第一次put时，该值为null
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //记录原始的散列表大小
        int oldThr = threshold;  //当前使用的桶大小
        int newCap, newThr = 0; //初始化新值
        if (oldCap > 0) { //如果原始大小大于0 
            if (oldCap >= MAXIMUM_CAPACITY) { //如果桶大小大于最大容量，则直接返回Integer.MAX_VALUE,并返回原值，不做扩容处理
                threshold = Integer.MAX_VALUE; 
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)   //如果新值的2倍小于最大容量，并且原始大小大于默认初始化值
                newThr = oldThr << 1; // double threshold  //则设置新临界值为2倍原临界值
        }
        else if (oldThr > 0) // initial capacity was placed in threshold  
            newCap = oldThr;      
        else {               // zero initial threshold signifies using defaults   //如使用默认构造器，第一次put时肯定进入该代码段，即初始大小为默认16，初始临界值为12
            newCap = DEFAULT_INITIAL_CAPACITY;   
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr; //设置临界值变量为新计算的值
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //按照新算出来的大小来初始化一个新的散列表
        table = newTab; //将新桶赋值给成员变量
        if (oldTab != null) { //如果旧的散列表里有数据，将旧散列表中的数据取出按新散列表大小重新计算BucketIndex，并存于新散列表中
            for (int j = 0; j < oldCap; ++j) { 
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
　　　　　//for循环中的代码，逐个遍历链表，重新计算索引位置，将老数组数据复制到新数组中去（数组不存储实际数据，所以仅仅是拷贝引用而已）
        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);
　　　　　　　　　 //将当前entry的next链指向新的索引位置,newTable[i]有可能为空，有可能也是个entry链，如果是entry链，直接在链表头部插入。
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

当桶容量过大时也要转化为红黑树：

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
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
　　　　　　　　　　　　//hd指向头结点
                    hd = p;
                else {
                    //这里其实是将单链表转化成了双向链表，tl是p的前驱，每次循环更新指向双链表的最后一个元素，用来和p相连，p是当前节点
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                //将链表进行树化
                hd.treeify(tab);
        }
    }  

构建红黑树函数：

 final void treeify(Node<K,V>[] tab) {
            TreeNode<K,V> root = null;//定义根节点
	    //x是当前节点，next是后继
            for (TreeNode<K,V> x = this, next; x != null; x = next) { 
                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;//如果根节点为null,把当前节点设置为根节点
                if (root == null) {
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                else {
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    //这里循环遍历，进行儿茶搜索树的插入
                    for (TreeNode<K,V> p = root;;) {
		 //p指向遍历中的当前节点，x为待插入节点，k是x的key，h是x的hash值，ph是p的hash值，dir用来指示x节点与p的比较
		//，-1表示比p小，1表示比p大，不存在相等情况，因为HashMap中是不存在两个key完全一致的情况。
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
		//如果hash值相等，那么判断k是否实现了comparable接口，如果实现了comparable接口就使用compareTo进行进行比较，
		//如果仍旧相等或者没有实现comparable接口，则在tieBreakOrder中比较
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);
                    TreeNode<K,V> xp = p;
                   if ((p = (dir <= 0) ? p.left : p.right) == null) {
                        x.parent = xp;
                        if (dir <= 0)
                            xp.left = x;
                        else
                            xp.right = x;
                        root = balanceInsertion(root, x);进行插入平衡处理
                        break;
                    }
                }
            }
        }
   //确保给定节点是桶中的第一个元素
        moveRootToFront(tab, root);
    }

总结：
1.resize时，HashMap使用新数组代替旧数组，对原有的元素根据hash值重新就算索引位置，重新安放所有对象；resize是耗时的操作。
2.每次resize新的散列数组长度是原来的2倍
3.当HashMap散列数组的长度大于>2的30次幂将不再扩充数组，直接将数组大小设置为Integer.MAX_VALUE
4.当hash碰撞较多时，链表长度大于等于8将转换单链表至红黑树（Java8优化）
优化hashMap
由以上代码分析得知为使 Map 对象有效地处理任意数目的项，Map 实现可以调整自身的大小。但调整大小的开销很大。
调整大小需要将所有元素重新插入到新数组中，这是因为不同的数组大小意味着对象现在映射到不同的索引值。先前冲突的键可能不再冲突，
而先前不冲突的其他键现在可能冲突。这显然表明，如果将 Map 调整得足够大，则可以减少甚至不再需要重新调整大小，这很有可能显著提高速度。

如何提升性能？

1、当你要创建一个比较大的hashMap时，充分利用另一个构造函数
/**

• Constructs an empty HashMap with the specified initial
  capacity and load factor.
  *
  • @param initialCapacity the initial capacity
    @param loadFactor the load factor
    • @throws IllegalArgumentException if the initial capacity is negative
      or the load factor is nonpositive
      */
      public HashMap(int initialCapacity, float loadFactor)

2、结合阿里开发规范：

【推荐】集合泛型定义时，在 JDK7 及以上，使用 diamond 语法或全省略。
说明：菱形泛型，即 diamond，直接使用<>来指代前边已经指定的类型。
正例：
// <> diamond 方式
HashMap userCache = new HashMap<>(16);
// 全省略方式
ArrayList users = new ArrayList(10);

【推荐】集合初始化时，指定集合初始值大小。
说明：HashMap 使用 HashMap(int initialCapacity) 初始化。
正例：initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即 loader
factor）默认为 0.75，如果暂时无法确定初始值大小，请设置为 16（即默认值）。
反例：HashMap 需要放置 1024 个元素，由于没有设置容量初始大小，随着元素不断增加，容
量 7 次被迫扩大，resize 需要重建 hash 表，严重影响性能

关于红黑树：
红黑树比较传统的定义是需要满足以下五个特征：
（1）每个节点或者是黑色，或者是红色。
（2）根节点是黑色。
（3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
（4）如果一个节点是红色的，则它的子节点必须是黑色的。
（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
红黑树相比avl树，在检索的时候效率其实差不多，都是通过平衡来二分查找。但对于插入删除等操作效率提高很多。
红黑树不像avl树一样追求绝对的平衡，他允许局部很少的不完全平衡，这样对于效率影响不大，但省去了很多没有必
要的调平衡操作，avl树调平衡有时候代价较大，所以效率不如红黑树。