hasmap源码分析（jdk1.8）

看了源码，也看了好多关于hasmap源码分析的博客，总结一下。

---

在JDK1.6中，HashMap采用数组（位桶）+链表实现即使用链表处理冲突，同一hash值的数据都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组（位桶）+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，桶中的结构可能是链表，也可能是红黑树，红黑树的引入是为了提高效率！

---

简单说明：将数据存放在数组中，按照hascode值存放，因为hascode可能相同，所以将这个值相同的存放在这个数组的链表中。在查找时可以先确定在数组的位置，在进行遍历链表，在jdk1.8中加入了红黑树，当链表长度超过阈值（8）时，将链表转换为红黑树，再一次提高了效率。

---

1.继承关系

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

可以看到HashMap继承自父类（AbstractMap），实现了Map、Cloneable、Serializable接口。其中，Map接口定义了一组通用的操作；Cloneable接口则表示可以进行拷贝，在HashMap中，实现的是浅层次拷贝，即对拷贝对象的改变会影响被拷贝的对象（拷贝对象的内容可以查看博客的原型模式）；Serializable接口表示HashMap实现了序列化，即可以将HashMap对象保存至本地，之后可以恢复状态。

---

2.类的属性：

//序列号private static final long serialVersionUID = 362498820763181265L;//默认初始容量static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16//最大容量  2的30次方static final int MAXIMUM_CAPACITY = 1 << 30;//填充比，装载因子，表征着hash表中的拥挤情况，static final float DEFAULT_LOAD_FACTOR = 0.75f;//加载因子是表示Hsah表中元素的填满的程度.若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.//当某个桶中的键值对数量大于8个【9个起】，且桶数量大于等于64，则将底层实现从链表转为红黑树   // 如果桶中的键值对达到该阀值，则检测桶数量  static final int TREEIFY_THRESHOLD = 8;//jdk1.8新加// 当桶(bucket)上的结点数小于这个值时树转链表//仅用于TreeNode的final void split(HashMap<K,V> map, Node<K,V>[] //tab, int index, int bit) {//            if (lc <= UNTREEIFY_THRESHOLD)  //                   //太小则转为链表  //                   tab[index] = loHead.untreeify(map); ////        }static final int UNTREEIFY_THRESHOLD = 6;//jdk1.8新加//链表转树时，if (tab == null || (n = tab.length) < //MIN_TREEIFY_CAPACITY)//resize(); // 即不转为树了//当桶数量到达64个的时候，才可能将链表转为红黑树static final int MIN_TREEIFY_CAPACITY = 64;transient Node<K,V>[] table;//存储元素(位桶)的数组transient Set<Map.Entry<K,V>> entrySet;// 存放具体元素的集transient int size;//实际容量transient int modCount;//结构改变次数，fast-fail机制int threshold;// 新的扩容resize临界值,当实际大小(容量*填充比)大于临界值时，会进行2倍扩容final float loadFactor; // 填充因子

---

2.基本类
Node内部类：
是HashMap内部类（jdk1.6就是Entry），继承自 Map.Entry这个内部接口，它就是存储一对映射关系的最小单元，也就是说key，value实际存储在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);        }//按位异或^不同为真,数a两次异或同一个数b(a=a^b^b)仍然为原值a。          public final V setValue(V newValue) {            V oldValue = value;            value = newValue;            return oldValue;        }// 优化逻辑  当key相同时进行覆盖。        public final boolean equals(Object o) {//equals方法，进行元素key值比较。            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;        }    }

TreeNode红黑树

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;   //节点的前一个节点          boolean red;//true表示红节点，false表示黑节点          TreeNode(int hash, K key, V val, Node<K,V> next) {            super(hash, key, val, next);        }          //获取红黑树的根          final TreeNode<K,V> root() {}        //确保root是桶中的第一个元素，将root移到桶中的第一个【平衡思想】        static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {......}        //查找hash为h，key为k的节点           final TreeNode<K,V> find(int h, Object k, Class<?> kc) {}        //获取树节点，通过根节点查找           final TreeNode<K,V> getTreeNode(int h, Object k) {            return ((parent != null) ? root() : this).find(h, k, null);        }        //比较2个对象的大小          static int tieBreakOrder(Object a, Object b) {.......}        //将链表转为二叉树          final void treeify(Node<K,V>[] tab){......}        //将二叉树转为链表         final Node<K,V> untreeify(HashMap<K,V> map){......}        //添加一个键值对        final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab, int h, K k, V v) {.....}        //移除一个节点        final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,boolean movable){......}        //将节点太多的桶分割        final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {......}        //左旋转        static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,TreeNode<K,V> p) {......}        //右旋转        static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,TreeNode<K,V> p) {......}        //保持插入后平衡        static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,TreeNode<K,V> x) {.......}        //删除后调整平衡         static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,TreeNode<K,V> x) {......}        //检测是否符合红黑树        static <K,V> boolean checkInvariants(TreeNode<K,V> t){.....}

3.构造函数:

 public HashMap(int initialCapacity, float loadFactor) {        if (initialCapacity < 0)//如果初始容量小于0抛出异常            throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);            //初始容量大于最大值时，将初始容量设置为最大值        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;            // 填充因子不能小于或等于0，不能为非数字，否则抛出异常        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " +loadFactor);        this.loadFactor = loadFactor;// 初始化填充因子          this.threshold = tableSizeFor(initialCapacity);//计算扩容值。    }

//返回大于等于initialCapacity的最小的二次幂数值。//>>> 操作符表示无符号右移，高位取0。//计算下次需要调整大小的扩容resize临界值  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;    }// 计算新的扩容临界值，不再是JDK1.6的while循环来保证哈希表的容量一直是2的整数倍数，用移位操作取代了1.6的while循环移位（不断乘2）length为2的整数幂保证了length - 1 最后一位（二进制表示）为1，从而保证了索引位置index即（ hash &length-1）的最后一位同时有为0和为1的可能性，保证了散列的均匀性。反过来讲，若length为奇数，length-1最后一位为0，这样与h按位与【同1为1】的最后一位肯定为0，即索引位置肯定是偶数，这样数组的奇数位置全部没有放置元素，浪费了大量空间。//length为2的幂保证了按位与最后一位的有效性，使哈希表散列更均匀。

public HashMap(int initialCapacity) {        // 调用HashMap(int, float)型构造函数，传入初始容量和初始填充因子        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }

public HashMap() {         // 初始化填充因子        this.loadFactor = DEFAULT_LOAD_FACTOR;     }

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

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {        int s = m.size();        if (s > 0) {        // 判断table是否已经初始化            if (table == null) { // pre-size            // 未初始化，s为m的实际元素个数                float ft = ((float)s / loadFactor) + 1.0F;                int t = ((ft < (float)MAXIMUM_CAPACITY) ?                         (int)ft : MAXIMUM_CAPACITY);                if (t > threshold)                // 计算得到的t大于阈值，则初始化阈值                    threshold = tableSizeFor(t);            }            // 已初始化，并且m元素个数大于阈值，进行扩容处理            else if (s > threshold)                resize();                // 将m中的所有元素添加至HashMap中            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {                K key = e.getKey();                V value = e.getValue();                putVal(hash(key), key, value, false, evict);            }        }    }

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node<K,V>[] tab; Node<K,V> p; int n, i;        if ((tab = table) == null || (n = tab.length) == 0)//table空||length为0             n = (tab = resize()).length;// 分配空间，初始化         if ((p = tab[i = (n - 1) & hash]) == null))//hash所在位置(第i个桶)为null，直接put              tab[i] = newNode(hash, key, value, null);        else {//tab[i]有元素，则需要遍历结点后再添加              Node<K,V> e; K k;            // hash、key均等，说明待插入元素和第一个元素相等，直接更新              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) {//死循环，直到break                      if ((e = p.next) == null) {//表尾仍没有key相同节点,新建节点                          p.next = newNode(hash, key, value, null);                        if (binCount >= TREEIFY_THRESHOLD - 1) // //若链表数量大于阀值8【9个】，则调用treeifyBin方法，仅当tab.length大于64才将链表改为红黑树                   // 如果tab.length<64或table=null，则重构一下链表                             treeifyBin(tab, hash);//binCount>=9则链表转树                          break; // 退出循环                     }                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))// hash、key均相等，说明此时的节点==待插入节点，更新                        break;                    p = e;//更新p指向下一个节点                  }            }            //当前节点e = p.next不为null，即链表中原本存在了相同key，则返回oldValue              if (e != null) { // existing mapping for key //onlyIfAbsent值为false，参数主要决定当该键已经存在时，是否执行替换                  if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }        ++modCount;        if (++size > threshold)//++size后再检测是否到了阀值              resize();        afterNodeInsertion(evict);//调用linkedHashMap,true则possibly remove eldest          return null;// 原hashMap中不存在相同key的键值对，则在插入键值对后，返回null    }

resize函数：

//两倍扩容并初始化table  final Node<K,V>[] resize() {        Node<K,V>[] oldTab = table;         // 保存table大小        int oldCap = (oldTab == null) ? 0 : oldTab.length;        // 保存当前阈值         int oldThr = threshold;        int newCap, newThr = 0;// 新容量，新阀值          // 之前table大小大于0        if (oldCap > 0) {        // 之前table大于最大容量            if (oldCap >= MAXIMUM_CAPACITY) {            // 阈值为最大整形                threshold = Integer.MAX_VALUE;                return oldTab;//到达极限，无法扩容              }            // 容量翻倍，使用左移，效率更高            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)                      // 阈值翻倍                newThr = oldThr << 1;         }         // 之前阈值大于0        else if (oldThr > 0)             newCap = oldThr;            // oldCap = 0并且oldThr = 0，使用缺省值（如使用HashMap()构造函数，之后再插入一个元素会调用resize函数，会进入这一步）        else {            newCap = DEFAULT_INITIAL_CAPACITY;            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);        }        if (newThr == 0) {//新阀值为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;        // table初始化,bucket copy到新bucket，分链表和红黑树        if (oldTab != null) {        // 不为空则挨个copy            for (int j = 0; j < oldCap; ++j) {                Node<K,V> e;                if ((e = oldTab[j]) != null) {                    oldTab[j] = null;//置null，主动GC                      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 {//链表                        Node<K,V> loHead = null, loTail = null;//lo原bucket的链表指针                          Node<K,V> hiHead = null, hiTail = null;//hi新bucket的链表指针                        Node<K,V> next;                         // 将同一桶中的元素根据(e.hash & oldCap)是否为0进行分割，分成两个不同的链表，完成rehash                        do {                            next = e.next;                            if ((e.hash & oldCap) == 0) {//还放在原来的桶                                if (loTail == null)                                    loHead = e;                                else                                    loTail.next = e;                                loTail = e;//更新尾指针                              }                            else {//放在hiHead开头的链表中                                if (hiTail == null)                                    hiHead = e;                                else                                    hiTail.next = e;                                hiTail = e;                            }                        } while ((e = next) != null);                        if (loTail != null) {//原bucket位置的尾指针不为空                            loTail.next = null;//将尾指针为空                            newTab[j] = loHead;//链表头指针放在新桶的相同下标(j)处                         }                        if (hiTail != null) {                            hiTail.next = null;//将尾指针为空                            newTab[j + oldCap] = hiHead;//放在桶 j+oldCap                          }                    }                }            }        }        return newTab;    }

关于元素位置在【j】或【j+oldCap】

HashMap在Resize时，只需看(新)n-1最高位对应的hash(key)位是0还是1即可，0则位置不变，1则位置变为原位置+oldCap。如何确认(新)n-1最高位对应的hash(key)位是0还是1呢？源码给出了很巧妙的方式（e.hash & oldCap）：e即Node，由put和Node构造函数相关源码可知，e.hash即为hash(key)；oldCap为0001 0000（仅最高位为1）； 相&为0说明e.hash最高位为0，否则为1.

由于所计算的hash(key)位是1是0可以认为是随机的，所以将一个冲突长链表又“均分”成了两个链表，减少碰撞。