hasmap源码分析（jdk1.8）

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可以认为是随机的，所以将一个冲突长链表又“均分”成了两个链表，减少碰撞。