Map—HashMap源码剖析

Map接口是java中保存二元偶对象（键值对）的最顶层接口
Map接口下的常用子类
HashMap（使用频率最高）、TreeMap、Hashtable、ConcurrentHashMap

Map集合的遍历： 将Map集合转化为Set集合进行遍历

• 使用迭代器进行输出：Iterator

 Set<Map.Entry<Integer,String>> entrySet =
                map.entrySet();//将Map变为Set  通过Set取得迭代器
        Iterator<Map.Entry<Integer,String>> iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry<Integer,String> entry =
                    iterator.next();
            System.out.println(entry.getKey()+" "+entry.getValue());
        }

映射：一个键对应一个值
将每一对key和value看做一个对象，每一个对象就是一个Entry，一个Map是由多个Entry对象来组成的。调用entrySet()方法后返回Set<Map.Entry<Integer,String>>类型集合
Map.Entry的作用：Map.Entry里有相应的getKey和getValue方法，让我们能够同时取出Key和Value者一对值。
下面让我们以Map中的HashMap为例，探究一下源码的实现：
首先有这么几个成员变量：

• 初始化容量：DEFAULT_INITIAL_CAPACITY = 16；桶的数量
• 负载因子：DEFAULT_LOAD_FACTOR = 0.75f（扩容时）
• 树化阈值：TREEIFY_THRESHOLD = 8
• 树化的最少元素个数：MIN_TREEIFY_CAPACITY = 64
• 解树化，返回链表阈值：UNTREEIFY_THRESHOLD = 6**

构造方法：

• 无参构造：这里并没有初始化HashMap,而只是初始化了负载因子

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

• 有参构造：一个参数的构造方法只是调用了有参的构造方法

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

• 有参构造：两个参数的构造方法也没有进行初始化，只是将变量进行赋值
  

普通方法：

• static final int tableSizeFor(int cap)

  tableSizeFor（）这个方法的作用是将输入的参数变为距离这个数最近的2 的整数次方

• put（）方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
//当前hash表未初始化
    if ((tab = table) == null || (n = tab.length) == 0)
//resize（）完成哈希表初始化
        n = (tab = resize()).length;
//根据key值hash后得到桶下标，并且此时桶中元素个数为空
    if ((p = tab[i = (n - 1) & hash]) == null)
//将要保存的结点放置在此桶的第i个元素
        tab[i] = newNode(hash, key, value, null);
    else {//此时hash表已经初始化了并且桶中已经有数据了
        Node<K,V> e; K k;
//若桶中原来元素的hash=你要设置的元素的hash且桶中原来元素的key=你要设置的元素的key
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
//将value做替换
            e = p;
//hash（key）桶中元素不为空，判断此桶是否树化
        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);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((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;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
//判断添加元素之后整个哈希表大小是否超过threshod
    if (++size > threshold)
//若超过，调用resize（）方法扩容
        resize();
    afterNodeInsertion(evict);
    return null;
}

向HashMap中添加元素时，存在树化逻辑，删除时存在解树化

• 树化逻辑：当一个桶中链表元素个数>=8并且哈希表的长度超过64，此时会将此桶中链表结构转为红黑树，若只是链表个数>8,但哈希表的元素不超过64，此时只是简单的resize（扩容），并不会树化。（提高链表过长导致的查找太慢问题，从原来的O（n）优化为O（log n），减少hash碰撞）
• 解树化：当红黑树节点个数在扩容或删除时个数<=6,在下一次扩容时会将红黑树转化为链表

将put方法看完后就会提出几个问题：
1.HashMap中容量均为2^n
保证哈希表中的所有索引都能被访问到。
举个例子，如果容量是15，那利用（n-1）&hash进行运算时，n-1的二进制码后四位为1110，这样无论hash值是多少都会出现有的索引不被访问到。所以就要保证是2 ^n。此时n-1 的二进制位1111,就不会出现这种问题。当n为2的n次方时，此时的位运算就相当于hash%n

2.负载因子：DEFAULT_LOAD_FACTOR = 0.75f作用？
计算有效桶个数：threshold=桶个数*负载因子
当负载因子>0.75时：增加了哈希表的利用率，哈希冲突概率明显增加
当负载因子<0.75时：降低了哈希表的利用率，导致频繁扩容，哈希冲突概率明显降低

• get方法：

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))))
        //当前节点key值刚好是桶的第一个节点
            return first;
       //遍历桶的其他节点找到指定key值返回其value
        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);
        }
    }
    //当表还未初始化或key值为null
    return null;
}

看这段源码：为何取出key值的高16位右移参与hash运算？（h >>> 16）

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

因为hash基本上是在高16位进行hash运算，保留高16位，让高低16位都参与异或运算，降低hash冲突的概率

• resize方法：
  如果表为null，则oldCap=0；若oldCap>0,并且已经大于等于最大容量，就让有效桶个数等于整型最大值，返回原来的表，当oldCap扩大2倍后仍小于最大容量，并且oldCap大于默认容量，就让他扩容两倍，否则进行初始化操作
  在HashMap扩容之后要进行数据的搬移，在搬移的过程中原来的元素在新的HashMap中的位置是原位置或原位置的2倍。
  原因是：假设原来容量为16 ，根据下列公式进行计算
  
  *