【JAVA集合VI-Map接口实现类HashMap】

1.HashMap底层结构

2.HashMap说明

（1）说明

1. HashMap是Map接口使用频率最高的实现类
2. HashMap是以key-val对的方式来存储数据（HashMap￥Node类型）
3. key不能重复，但是值可以重复，允许使用null键和null值
4. 如果添加相同的key，则会覆盖原来的key-val，等同于修改（key不会替换，val会替换）
5. 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的（jdk8的hashMap底层 数组+链表+红黑树）
6. HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有synchronized。

（2）方法

3.HashMap底层机制及源码剖析

（1）首先，看一个示意图

（2）底层级制及源码剖析

1. HashMap底层维护了Node类型的数组table，默认为null
2. 当创建对象时，将加载因子（loadfactor）初始化为0.75
3. 当添加key-val时，通过key的哈希值得到在table的索引，然后判断该索引处是否有元素，如果没有元素直接添加；如果该索引处有元素，继续判断该元素的key和准备加入的是否相等，如果相等，则直接替换val；如果不相等，需要判断是树结构还是链表结构，做出相应处理，如果添加成功时发现容量不够，则需要扩容。
4. 第一次添加，则需要扩容table容量为16，临界值（threshold）为12（16*0.75）
5. 以后再扩容，则需要扩容table容量为原来的2倍（32），临界值为原来的2倍，即24，以此类推
6. 在java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD（默认值为8），并且table的大小>=MIN_TREEIFY_CAPACITY（默认为64），就会进行树化（红黑树）。

（3）具体代码理解

public class HashMapTest {

    public static void main(String[] args) {
        HashMap hashMap=new HashMap();
        hashMap.put("小米",20);
        hashMap.put("小红",23);
        hashMap.put("小李",25);


        /*
        1. 执行构造器 new HashMap()
        初始化加载因子 loadfactor = 0.75
        HashMap$Node[] table = null

        2. 执行 put 调用 hash 方法，
        计算 key 的 hash 值 (h = key.hashCode()) ^ (h >>> 16)
        public V put(K key, V value) {
        //K = "java" value = 10
        return putVal(hash(key), key, value, false, true);
         }

        3,执行putVal方式

         final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;//初始化变量
        /如果底层的 table 数组为 null, 或者 length =0 , 就扩容到 16
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
            //取出 hash 值对应的 table 的索引位置的 Node, 如果为 null, 就直接把加入的 k-v
            //, 创建成一个 Node ,加入该位置即可
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;//辅助变量
            // 如果 table 的索引位置的 key 的 hash 相同和新的 key 的 hash 值相同，
            // 并 满足(table 现有的结点的 key 和准备添加的 key 是同一个对象
            || equals 返回真) // 就认为不能加入新的 k-v
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
            //如果当前的 table 的已有的 Node 是红黑树，就按照红黑树的方式处
                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);/如果整个链表，没有和他相同,就加到该链表的最后
                        //加入后，判断当前链表的个数，是否已经到 8 个，到 8 个，后
                        //就调用 treeifyBin 方法进行红黑树的转换
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果在循环比较过程中，发现有相同,就 break,就只是替换 value
                    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;//每增加一个 Node ,就 size++
        if (++size > threshold))//如 size > 临界值，就扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }


        5. 关于树化(转成红黑树)
        //如果 table 为 null ,或者大小还没有到 64，暂时不树化，而是进行扩容.
        //否则才会真正的树化 -> 剪枝
         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<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }




        */

    }
}