Java数据结构之HashMap源码(基于JDK1.8)阅读(二)

开篇请读者思考一个问题

new HashMap()和new HashMap(0)的区别是什么？
new HashMap(3)和new HashMap(10)的初始容量又是多少呢？
回答这个问题必然要看下HashMap的构造函数。在JDK1.8中HashMap共有四个构造函数

无参构造

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

有参构造

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

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

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

写个测试Demo来回答下开始的那个问题
new HashMap()：

        Map map = new HashMap();
        Class<? extends Map> mapType = map.getClass();
        Field threshold = mapType.getDeclaredField("threshold");
        threshold.setAccessible(true);
        Method capacity = mapType.getDeclaredMethod("capacity");
        capacity.setAccessible(true);
        System.out.println("new HashMap()的初始容量是:" + capacity.invoke(map) +"-----初始阈值是:"+threshold.get(map));

        for (int i = 0; i < 17; i++) {
            map.put(i,i);
            System.out.println("new HashMap()的容量是:" + capacity.invoke(map) +"-----阈值是:"+threshold.get(map));
        }

运行结果:

new HashMap()的初始容量是:16-----初始阈值是:0
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:16-----阈值是:12
new HashMap()的容量是:32-----阈值是:24
new HashMap()的容量是:32-----阈值是:24
new HashMap()的容量是:32-----阈值是:24
new HashMap()的容量是:32-----阈值是:24
new HashMap()的容量是:32-----阈值是:24

new HashMap(0)

new HashMap(0)的初始容量是:1-----初始阈值是:1
new HashMap(0)的容量是:2-----阈值是:1
new HashMap(0)的容量是:4-----阈值是:3
new HashMap(0)的容量是:4-----阈值是:3
new HashMap(0)的容量是:8-----阈值是:6
new HashMap(0)的容量是:8-----阈值是:6
new HashMap(0)的容量是:8-----阈值是:6
new HashMap(0)的容量是:16-----阈值是:12
new HashMap(0)的容量是:16-----阈值是:12
new HashMap(0)的容量是:16-----阈值是:12
new HashMap(0)的容量是:16-----阈值是:12
new HashMap(0)的容量是:16-----阈值是:12
new HashMap(0)的容量是:16-----阈值是:12
new HashMap(0)的容量是:32-----阈值是:24
new HashMap(0)的容量是:32-----阈值是:24
new HashMap(0)的容量是:32-----阈值是:24
new HashMap(0)的容量是:32-----阈值是:24
new HashMap(0)的容量是:32-----阈值是:24

所以我们可以得出结论：

无参构造	有参构造
无put操作:阈值=0；容量=默认初始值=16	无put操作：阈值=容量；容量=比参数容量大的最小二次幂
有put操作：阈值=容量*加载因子	有put操作和无参构造相同

容量是从下面的方法得出的

    final int capacity() {
        return (table != null) ? table.length :
            (threshold > 0) ? threshold :
            DEFAULT_INITIAL_CAPACITY;
    }

而有参构造中的

this.threshold = tableSizeFor(initialCapacity);

是一个算法,它的作用是返回给定比目标容量大的最小二次幂

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

这个算法大概是这样：
假设n = 01xx xxxx xxxx xxxx
那么按照以上程序来进行或等操作就会得到下面的结果
n = 011x xxxx xxxx xxxx
n = 0111 1xxx xxxx xxxx
n = 0111 1111 1xxx xxxx
…
依次顺序，必然会将原n的高位1后面的值全部变成1，即0111 1111 1111 1111
最后在加1，就会得到大于n的最小二次幂1000 0000 0000 0000,读者不理解可以手动模拟一下，体会一下数学的魅力（我大学数学专业的，这句话绝对负责,哈哈）。读到这里应该能回答的上文章开头的那两个问题了吧。
重点来了，我们使用最多的put操作又是怎么个逻辑的呢？
这部分也是面试中爱问的，这里我会分析的很详细。
上源码！

	/*
	*hash 键的hash值
	*key 键
	*value 值
	*/
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //tab 哈希表的副本指向同一块内存地址-------全局属性table
        //p 哈希表上的头节点的副本指向同一块内存地址-------table上的Node节点，也就是Node[i]
        //n 哈希表长度的副本
        //i 哈希表的索引副本           
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //HashMap的懒加载机制
        if ((tab = table) == null || (n = tab.length) == 0)
        	//重构hash表(其实这个resize()方法还挺复杂的)
            n = (tab = resize()).length;
         //用key的hash值和n-1进行与运算，判断该位置是否有节点Node
        if ((p = tab[i = (n - 1) & hash]) == null)
        	//替换为新节点
            tab[i] = newNode(hash, key, value, null);
        else {
        	//出现了hash冲突
        	//e Node节点副本
        	//k 键的副本
            Node<K,V> e; K k;
            //如果刚刚位置上的Node1的键的hash值和要put进来的新节点Node2的键的hash值相同
            //并且Node1的键和Node2的键划==号,或者能equals为true
            //这里读者请思考一下，一个类只重写hashcode不重写equals方法在进行put的时候会出现什么问题？
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //满足条件则说明需要新值覆盖旧值
                //拿到旧节点的副本e
                e = 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);
                        //当链式结构节点数量到达阈值，则要将其转换成红黑树，红黑树单独分析，因为它比较复杂
                        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);//回调函数,给linkedHashMap使用的
                return oldValue;//返回旧值
            }
        }
        ++modCount;//迭代器快速失败，也是防止多线程操作
        if (++size > threshold)
            resize();//重构hash表，这里会出现线程不安全的情况，有点复杂的，单独分析
        afterNodeInsertion(evict);//成功插入后的回调函数
        return null;
    }

后面，会分析put方法中的一些重要的方法