一 HashMap HashTable HashSet

        HashMap是一个散列表，存储的内容是键值对(key-value)映射。它继承于AbstractMap，实现了Map、Cloneable、Serializable接口。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。HashMap中的映射不是有序的。

        JDK1.6中，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个数组中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值8时，将链表转换为红黑树，这样大大减少了查找时间。原本Map.Entry接口的实现类Entry改名为了Node。转化为红黑树时改用另一种实现TreeNode。

        HashTable内部实现基本和HashMap一样，只是在方法上都加了synchronized关键字，保证了线程安全；它的key和value都不可以为null；Hashtable和HashMap扩容的方法不一样，Hashtable中数组默认大小11，扩容方式是 old*2+1。

        HashSet继承了AbstractSet，实现了Set, Cloneable,Serializable。内部是依赖HashMap实现的，HashSet里面有一个HashMap(适配器模式)，所以HashSet的结构比较简单。不保证元素的迭代顺序一直不变，允许有一个null。非线程安全。

        综上，我们可以看出HashMap是这3个集合的核心，都是围绕这一个思想或源码实现的，我们详细介绍HashMap源码，HashTable HashSet了解他们与HashMap区别即可。

二 HashMap HashTable HashSet 区别

        HashMap与HashTable区别：内部实现基本一致，HashMap key value可以为null，而HashTable不行；他们默认数组长度不同，HashMap默认数组长度16，HashTable默认长度11；扩容方式不同，HashMap扩容为原来的2倍，HashTable扩容old*2+1。

        HashMap与HashSet区别：HashMap实现了Map接口，HashSet实现的是Set接口；HashMap存储的键值对，HashSet存储的是对象；HashMap会对key计算hash，而HashSet是对对象计算hash（因为它只有对象），其实HashSet是把对象当作HashMap的key存放进去的。

三 HashMap常量定义

// 默认初始容量必须是2的幂，默认是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

// 最大容量（必须是2的幂且小于2的30次方，如果在构造函数中传入过大的容量参数将被这个值替换）
static final int MAXIMUM_CAPACITY = 1 << 30;

// 默认负载因子，啥叫负载因子呢，HashMap通过负载因子与桶的数量计算得到所能容纳的最大元素数量
// 计算公式为threshold = capacity * loadFactor
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 链表转化为红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;

// 红黑树转化为链表的阈值，扩容时才可能发生
static final int UNTREEIFY_THRESHOLD = 6;

// 进行树化的最小容量，防止在调整容量和形态时发生冲突
static final int MIN_TREEIFY_CAPACITY = 64;

四 构造方法

        构造方法都没有初始化数组及内部node类，都是第一次添加元素时才真正实例化对象，构造函数只是把常量赋值

    // 指定初始化长度和扩容因子
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        // 大于2的30次方，默认赋值为2的30次方
        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(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    // 默认赋值扩容因子
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

五 新增方法

        计算key的hash做异或位移运算（把key打散到不同的数组上）；如果是第一次添加则初始化数组，否则根据key计算出的数组下标插入值，如果当前数组为空则直接插入，如果当前数组元素为红黑树则利用红黑树插入，否则为链表结构，遍历链表，插入尾部，遍历发现重复key直接替换；最后判断是否超出阈值，判断是否要扩容

    // 新增key
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    // 计算key的hash后；高16位保持不变，低16位与高16位异或作为key的最终hash值；
    // 如此设置的原因是因为下标的计算是：n = table.length; index = (n-1) & hash;
    // table的长度都是2的幂，因此index仅与hash值的低n位有关
    // hash值的高位都被与操作置为0了，所以异或降低冲突
    // 想达到的效果就是尽量把key打散到不同的数组上
    // 而且在扩容的时候能保证当前数组链表的值停留在当前数组或者当前数组的2倍
    // 如key初始保存在数组下标为2，扩容后数组下标为2的链表数据不是在数组下标为2就是在数组下标为18的位置
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    // 第四个参数 onlyIfAbsent 如果是 true，那么只有在不存在该 key 时才会进行 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;
        // 第一次 put 值的时候，会触发下面的 resize()
        // 第一次 resize 和后续的扩容有些不一样，因为这次是数组从 null 初始化到默认的 16 或自定义的初始容量
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 根据key的hash值得到插入的数组索引i，如果table[i]==null，直接新建节点并添加
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 否则此处有数据
        else {
            Node<K,V> e; K k;
            // 判断第一个节点是否和当前值相等，如果相等直接替换
            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 {
                // 遍历table[i]
                for (int binCount = 0; ; ++binCount) {
                    // 插入到链表的最后面(Java7 是插入到链表的最前面)；若链表长度小于8，执行链表的插入操作
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 若链表长度大于等于8，将链表转换为红黑树并执行插入操作
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 在遍历过程中，若发现key已经存在则直接覆盖value
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 若key已经存在，用新的value替换原先的value，并将原先的value返回
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        // 插入成功后，判断实际存在的键值对数量size是否超过最大容量threshold，如果超过则调用resize扩容
        // 和 Java7 稍微有点不一样的地方就是，Java7 是先扩容后插入新值的，Java8 先插值再扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

六 resize()方法

        初始化或扩容大小。 如果为空，则根据字段阈值中持有的初始容量目标进行分配。 否则，因为我们使用的是 2 的幂扩展，所以每个数组中的元素保持停留原数组，或者在新扩容数组以 2 的幂的偏移量移动（比如a，b，c之前停留在数组1上，扩容16个长度后，要不还停留在1，要不停留到17）

        判断当前数组长度是否为最大长度，如果为最大长度则不扩容，返回原数组；如果没超过就扩容为原来的2倍；再判断是否初始化插入，如果是则初始化长度的数组；否则就是需要扩容为原来的2倍，遍历旧的table，存放到2个链表内，原位置链表和新位置链表（因为用的是2的幂次方高低位运算，只会停留原位置，和扩容后位置），判断存放到不同链表后，最后插入到相应扩容后数组位置

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            // 如果扩容前的数组大小超过最大容量
            if (oldCap >= MAXIMUM_CAPACITY) {
                // 修改resize阈值为int的最大值(2^31-1)，这样以后就不会扩容了
                threshold = Integer.MAX_VALUE;
                // 直接将原数组返回
                return oldTab;
            }
            // 没超过最大容量，就将容量扩充为原来的两倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 将新的resize阈值也扩充为原来的两倍
                newThr = oldThr << 1; // double threshold
        }
        // 对应使用 new HashMap(int initialCapacity) 初始化后，第一次 put 的时候
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        // 对应使用 new HashMap() 初始化后，第一次 put 的时候
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 计算新的resize阈值
        if (newThr == 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];
        // 如果是初始化数组，到这里就结束了，返回 newTab 即可
        table = newTab;
        if (oldTab != null) {
            // 遍历旧的table
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    // 释放旧table的对象引用（for循环后，旧的table不再引用任何对象）
                    oldTab[j] = null;
                    // 若oldTab[j]只包含一个元素
                    if (e.next == null)
                        // 直接将这一个元素放到newTab合适的位置
                        newTab[e.hash & (newCap - 1)] = e;
                    // 若oldTab[j]存储结构为红黑树，执行红黑树中的调整操作
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        // 若oldTab[j]存储结构为链表
                        // 需要将此链表拆成两个链表，放到新的数组中，并且保留原来的先后顺序
                        // 不需要重新计算元素在数组中的位置，采用原始位置加原数组长度的方法计算得到位置
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            // 通过位操作可以得到元素在数组中的位置是否需要移动
                            if ((e.hash & oldCap) == 0) {
                                // 链表为空时，当前节点设置为头节点
                                if (loTail == null)
                                    loHead = e;
                                // 不为空时，将尾节点的下一个设置为当前节点
                                else
                                    loTail.next = e;
                                // 将尾节点设置为当前节点，移动指针
                                loTail = e;
                            }
                            // 需要移动时
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

七 查找方法

        计算查询key的hash，计算出当前数组位置，判断是否为空；不为空则判断当前数组链表的第一个元素是否为空；判断当前元素是否事要查询元素，是则返回；否则判断第一个节点的下一个节点是否为空；判断当前链表是否为红黑树，红黑树用红黑树查询方式查询出元素；否则遍历当前链表判断equals方法相等则返回。

    public V get(Object key) {
        Node<K,V> e;
        // 求出key的hash值，并调用getNode
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        // 当table不为空，并且经过计算得到的插入位置table[i]也不为空时继续操作，否则返回null
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            // 判断table[i]的首个元素是否等于key，若相等将其返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                // 若存储结构为红黑树，则执行红黑树中的查找操作
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    // 若存储结构仍为链表，则遍历链表，找到key所在的位置
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

八 HashMap1.7与1.8的区别

        1. 实现方式不同，1.7采用数组加链表，1.8采用数组加链表加红黑树；为什么做这种优化，第一链表长度太长影响查询效率，转换为红黑树可以提高查询效率；第二链表在高并发扩容时容易形成循环链表，红黑树扩容利用高低位可以避免此问题

        2. hash算法简化，1.7hash算法复杂，因为要尽可能的把数据打散提升查询效率，但1.8引入了红黑树，同时hash算法优化为异或和右移运算可以更好的实现打散

        3. 插入位置不同，1.7采用头插法，1.8采用尾插法；因为1.8对链表元素个数并没有记录，插入完成之后才判断是否需要转换红黑树或转换链表

        4. 扩容方式不同，1.7扩容需要重新计算hash遍历到新的链表内，而且会反转链表，所以在并发下容易形成循环链表；1.8通过高低位的算法，顺序插入新链表不会出现循环链表情况