我爱八股之 Java集合类

题目：聊聊你知道的Java集合类

回答：
就从常用的说起，大类可以分LIst，Set，Map。
List中常用的有ArrayList和LinkedList，ArrayList底层是一个数组，数据结构理有一个elementData数组，初始容量是10。因为是数组，所以在获取元素的时候，可以通过元素下标获取，时间复杂度为O(1)，如果删除元素，它会通过数组的复制，把删除的元素后置位的元素前移一个单位。当插入元素时，可能会造成数组的扩容，默认是扩容到1.5倍，当然前提是不能大于最大值（Integer.MAX_VALUE - 8），所以整体来看时间复杂度是达到O(N)级别的。
LinkedList底层是一个双向链表，所以他是一个不连续的空间，添加元素可以直接通过修改指针完成，但是在获取元素时，需要通过坐标值进行遍历，虽然底层进行了简单的优化。即通过计算判断该元素位于链表的前半部分还是后半部分，但是总体来说终究是一个O(N)级别的时间复杂度。
ArrayList和LinkedList一样，都是线程不安全的，内部有一个modCount，起到一个类似版本号的作用，当对集合有修改动作时，会使modCount+1，当在迭代的时候，发现modCount变了，就会抛出异常。
Set的底层其实就是一个Map，不过是设置了一个默认的Value，所以直接讲Map吧
最常用的HashMap，底层结构是散列表，简单可以理解为数组加链表的形式，数组默认长度是16，可以指定，但是会通过计算转换为2的幂。它是一个懒加载的形式，也就是在插入第一个元素的时候才会初始化，这样可以节省空间。在插入节点时，通过计算找到其对应插入的数组的位置，如果已经有元素了，就会以链表的形式串起来，在JDK1.8之后，会有一个树化的操作，就是当链表长度达到8的时候，会进入一个叫treeifyBin的方法，会进行判断，如果当前数组还没初始化或者数组长度小于64，那会先扩容（2倍），否则会将链表树化成一棵红黑树。树化的原因是当链表过长时，在获取元素时，其实是要遍历链表，会影响查询效率。同样的，当因为删除节点链表小于6的时候，红黑树也会退化成链表。HashMap的扩容发生在它内部有一个负载因子（0.75），数组长度乘以负载因子就是扩容阈值，当集合中的元素达到扩容阈值后，就要进行扩容
涉及代码如下：

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //tab：引用当前hashMap的散列表
        //p：表示当前散列表的元素
        //n：表示散列表数组的长度
        //i：表示路由寻址 结果
        Node<K,V>[] tab; Node<K,V> p; int n, i;

        //延迟初始化逻辑，第一次调用putVal时会初始化hashMap对象中的最耗费内存的散列表
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

        //最简单的一种情况：寻址找到的桶位 刚好是 null，这个时候，直接将当前k-v=>node 扔进去就可以了
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

        else {
            //e：不为null的话，找到了一个与当前要插入的key-value一致的key的元素
            //k：表示临时的一个key
            Node<K,V> e; K k;

            //表示桶位中的该元素，与你当前插入的元素的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 {
                //链表的情况，而且链表的头元素与我们要插入的key不一致。
                for (int binCount = 0; ; ++binCount) {
                    //条件成立的话，说明迭代到最后一个元素了，也没找到一个与你要插入的key一致的node
                    //说明需要加入到当前链表的末尾
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //条件成立的话，说明当前链表的长度，达到树化标准了，需要进行树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            //树化操作
                            treeifyBin(tab, hash);
                        break;
                    }
                    //条件成立的话，说明找到了相同key的node元素，需要进行替换操作
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }

            //e不等于null，条件成立说明，找到了一个与你插入元素key完全一致的数据，需要进行替换
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }

        //modCount：表示散列表结构被修改的次数，替换Node元素的value不计数
        ++modCount;
        //插入新元素，size自增，如果自增后的值大于扩容阈值，则触发扩容。
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }



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