Java集合总览

1.总览

Java中的集合分List、Set、Queue、Map 4种类型。

List：大多数实现元素可以为null，可重复，底层是数组或链表的结构，支持动态扩容

Set：大多数实现元素可以为null但只能是1个，不能重复，

2.List

2.1 ArrayList

ArrayList继承AbstractList实现List接口，底层是对象数组，Object[]

可以有多个null，初始大小为10，每次扩容为原容量的1.5倍，

注意：通过下表查找元素效率高，查询要便利所有、插入、删除要大量移动元素效率低

2.2 LinkedList

LinkedList继承AbstractSequentialList实现List、Deque接口，底层是Node链表，可以双向遍历

可以有多个null，初始化没有没有初始任何存储，当有元素进来时，默认从last节点插入，构造链表

注意：通过下标查找元素效率低要遍历到下标位置，查询要遍历所有，插入头和尾很快，插入和删除索引位置需要先遍历到那里再插入和删除

2.3 Vector(线程安全)

Vector继承AbstractList实现List接口，底层和ArrayList一样也是对象数组，Object[]

它和ArrayList的唯一区别是：它是线程安全的，实现的方式是每个有线程安全风险的方法上添加 synchronized 进行同步

2.4 Stack(线程安全)

Stack继承Vector，是个先进后出的结构，底层和ArrayList一样也是对象数组，Object[]

2.5 CopyOnWriteArrayList(线程安全)

CopyOnWriteArrayList实现了List接口，底层和ArrayList一样也是对象数组，volatile Object[] array,注意这里用volatile进行了修饰，保证当array引用更改时，所有线程都能获取到最新的引用。

CopyOnWriteArrayList原理：读支持多线程并发读，写时复制原则

set(index, e) 过程：

先加锁，
获取原数组引用，
获取原值，
原值和新值不同时拷贝新数组，新数组值更新，更新array指向，返回旧值
原值和新值相同是，更新array指向(还是原来的)，返回旧值(还是原来的)
解锁

add(e)过程：

先加锁，
获取原数组引用，
拷贝新数组，新数组值更新，更新array指向，返回true，解锁

3.Set

3.1 HashSet

HashSet继承AbstractHashSet实现Set接口，底层实际是HashMap或LinkedHashMap，在底层数据结构是：Node[]数组+单链表+红黑树

可以为null，但只会有一个null，初始大小为16，加载因子是0.75，扩容时是2的倍数

当调用HashSet的add方法时，实际是调用HashMap的put方法，key是add的值，value是一个共享的Object变量。

注意：因为不是线程安全的，调用size方法，返回的size可能会和真实元素个数不一致

3.2 LinkedHashSet

LinkedHashSet继承HashSet，它的代码很少，因为它借助HashSet的LinkedHashMap为底层实现，完成插入顺序的HashSet

其余都和HashSet一致

3.3 TreeSet

TreeSet继承AbstractSet实现NavigableSet接口，和HashSet相比：

集合种的元素不保证插入排序，默认使用元素自然排序，可以自定义排序器
jdk1.8之后，集合中的元素不可以为null

TreeSet使用TreeMap实现，底层用的是红黑树。

注意：与HashSet相比，TreeSet的性能稍低，add、remove、search等操作时间复杂度为O(log n)，按照顺序打印n个元素为O(n)

3.4 CopyOnWriteArraySet(线程安全)

CopyOnWriteArraySet继承AbstractSet，底层使用的是CopyOnWriteArrayList，

当加入的数据不存在时，再添加

3.5 ConcurrentSkipListSet(线程安全)

ConcurrentSkipListSet继承了AbstractSet实现了NavigableSet接口，底层使用ConcurrentNavigableMap实现，和HashSet使用HashMap实现一致

数据不能为null，使用ConcurrentNavigableMap的key存储值，Boolean.TRUE最为ConcurrentNavigableMap的value

注意：此类线程安全且有序，可以传递一个排序器

4.Queue

Queue是一种先进先出的数据结构，形如我们现时生活中的排队，第一个到的排在最前面，后面到的依次向后排，第一个处理完后处理第二个。

Deque是在Queue的基础上支持从尾部取数据的功能，Deque能适合更多的场合

4.1ArrayDeque

ArrayDeque继承AbstractCollection实现了Deque接口，它底层是一个Object[]数组，它支持自动扩容，默认初始容量是16，当元素达到队列的容量后就自动以2的倍数扩容，元素不能是null。

原理：ArrayDeque里面维护了head和tail两个指针，两个指针初始都是0，表示的是Object[]数组的下标，

正常使用队列使用的是offer方法，offer调用的是addLast方法，此方法是先在tail位置放置元素，然后再移动tail指针指向下一个位置，如果下一个位置就是head指针指向的位置则表示数组已全部放置了数据，需要对其进行扩容

addFirst使用的是head指针，head指针向左移动，[head = (head - 1) & (elements.length - 1)] = 15，在数组的最后一个位置放入元素，如果再addFirst就是向14这个位置放置元素，

总结：ArrayDeque是一个双端队列，内部使用head和tail指针进行控制元素的进队和出队

注意：数字在计算机中是以补码的方式存储的，正数的补码等于自己的原码，负数的补码等于自己的原码除符号位取反再+1，如1的原码和补码都是00000001，-1的原码是10000001，反码是11111110，补码是11111111

4.2 PriorityQueue

PriorityQueue继承AbstractQueue，它底层是一个Object[]数组，它支持自动扩容，默认初始容量是11，当元素达到队列的容量后，它会判断当前容量是否小于64，小于64的话，容量+2否则容量扩大一倍；元素不能是null。

原理：PriorityQueue其实是一种堆排序结构，默认是小根堆，堆底层使用Object[]数组实现。

堆：1.堆中的某个节点总是大于或者不小于其父亲节点的值 2.堆总是一颗完全二叉树

重要方法逻辑：

插入元素：1.先将元素放入到堆的最后一个节点的位置(也就是数组的有效元素的最后的一个位置)注：此时空间不够时需要进行扩容。 2. 将最后插入的节点向上调整，直到满足堆的性质

删除元素(弹出堆的第一个元素)：1. 将堆顶元素和堆中的最后一个元素进行交换 2.删除堆的最后一个元素 3.对堆顶元素进行向下调整

效率：加入一个数的时间复杂度是logN;取最大数且继续维持大根堆的时间复杂度是logN；

4.3 DelayQueue(线程安全)

DelayQueue继承AbstractQueue实现BlockingQueue。它底层是PriorityQueue，依赖PriorityQueue的能力来存储元素。DelayQueue里的元素都有一个延期时间实现Delayed接口，PriorityQueue按照延期时间进行排序。当还未到延期时间，DelayQueue弹出的数据为空。DelayQueue的线程安全是使用ReentrantLock进行控制。

4.3.1 Thread lead 成员变量的用处

leader来减少不必要的等待时间,那么这里我们的DelayQueue是怎么利用leader来做到这一点的呢:

这里我们想象着我们有个多个消费者线程用take方法去取,内部先加锁,然后每个线程都去peek第一个节点.如果leader不为空说明已经有线程在取了,设置当前线程等待

if (leader != null)
   available.await();

如果为空说明没有其他线程去取这个节点,设置leader并等待delay延时到期,直到poll后结束循环

else {
     Thread thisThread = Thread.currentThread();
     leader = thisThread;
     try {
          available.awaitNanos(delay);
     } finally {
          if (leader == thisThread)
              leader = null;
     }
 }

take方法中为什么释放first元素

first = null; // don't retain ref while waiting

我们可以看到doug lea后面写的注释,那么这段代码有什么用呢？

　想想假设现在延迟队列里面有三个对象。

线程A进来获取first,然后进入 else 的else ,设置了leader为当前线程A
线程B进来获取first,进入else的阻塞操作,然后无限期等待
这时他是持有first引用的
如果线程A阻塞完毕,获取对象成功,出队,这个对象理应被GC回收,但是他还被线程B持有着,GC链可达,所以不能回收这个first.
假设还有线程C 、D、E.. 持有对象1引用,那么无限期的不能回收该对象1引用了,那么就会造成内存泄露.

4.4 ConcurrentLinkedQueue(线程安全)

ConcurrentLinkedQueue继承AbstractQueue实现Queue接口。它是一个线程安全的先进先出队列实现，内部维护了head和tail两个volatile的指针，它底层是链表，自定义了Node节点，Node类中用volatile声明了item和next变量，并使用CAS的方式设置节点的next节点等，不支持null元素。

下面以offer方法的注释来详细说明下ConcurrentLinkedQueue

public boolean offer(E e) {
    // 检查e是不是null，是的话抛出NullPointerException异常。
    checkNotNull(e);
    // 创建新的节点
    final Node<E> newNode = new Node<E>(e);

    // 将“新的节点”添加到链表的末尾。
    for (Node<E> t = tail, p = t;;) {
        Node<E> q = p.next;
        // 情况1：q为空，p是尾节点插入
        if (q == null) {
            // CAS操作：如果“p的下一个节点为null”(即p为尾节点)，则设置p的下一个节点为newNode。
            // 如果该CAS操作成功的话，则比较“p和t”(若p不等于t，则设置newNode为新的尾节点)，然后返回true。
            // 如果该CAS操作失败，这意味着“其它线程对尾节点进行了修改”，则重新循环。
            if (p.casNext(null, newNode)) {
                if (p != t) // hop two nodes at a time
                    casTail(t, newNode);  // Failure is OK.
                return true;
            }
        }
        // 情况2：p和q相等
        else if (p == q)
            p = (t != (t = tail)) ? t : head;
        // 情况3：其它
        else
            p = (p != t && t != (t = tail)) ? t : q;
    }
}

5.5 LinkedBlockingQueue(线程安全)

LinkedBlockingQueue继承AbstractQueue实现BlockQueue接口，底层是链表，使用ReentrantLock进行并发安全控制。不允许添加null。

注意：如果不传入参数则默认大小是Integer.max，如果传入参数则大小就是传入的数值，当queue中元素达到最大值时，put 添加元素操作会被阻塞，等queue中不满时才能继续插入，使用Condition notEmpty进行await和signal进行等待和唤醒

5.6 ArrayBlockingQueue(线程安全)

ArrayBlockingQueue继承AbstractQueue实现BlockingQueue，底层是数组，使用ReentrantLock进行并发安全控制。不允许添加null。

原理：使用takeIndex和putIndex对取出和放入的位置进行控制，当take时，取taskIndex的位置元素，当put时put putIndex位置的元素，take和put后，判断takeIndex和putIndex是否等于数组的长度，等于的话从0继续开始

注意：传入参数就是底层数组的大小，当queue中元素达到最大值时，put 添加元素操作会被阻塞，等queue中不满时才能继续插入，使用Condition notEmpty notFull两个进行控制

5.Map

5.1 HashMap

HashMap继承AbstractMap实现Map接口。底层是数组+链表+红黑树。允许key和value为null

扩容：HashMap初始容量是16，默认负载因子是0.75，当HashMap中的元素数量大于容量*负载因子则进行容量*2的扩容操作。

引入红黑树的原因：降低查找相同hash值节点的速度，红黑树也是一种平衡二叉树，当节点数量大于等于8且HashMap中的元素大于等于64的时候才会将链表转化成红黑树，当节点数量小于等于6的时候红黑树退化成链表

5.1.1 put方法

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

// 这就是那个扰动函数 作用：让key的hash值的高16位也参与路由运算(在hash表数组长度还不是很大的情况下，让hash值的高16位也参与进来)
// key如果是null则就放到 数组的0位置
// h      = 0010 1100 1010 0011 1000 0101 1101 1100
// ^
// h>>>16 = 0000 0000 0000 0000 0010 1100 1010 0011
//        = 0010 1100 1010 0011 1010 1001 0111 1111       
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    // tab: 引用当前哈希表的数组
    // p: 当前哈希表的元素
    // n: 哈希表数组的长度
    // i: 路由寻址的结果               
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 如果当前hashmap的数组为null或数据为0， 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 { // 存在和要插入元素相同hash值的元素
        // e: node临时元素
        // k: 临时的一个key
        Node<K,V> e; K k;
        // 表示数组中的元素与当前要插入的元素 完全一致，表示后续需要进行替换操作
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // P元素已经树化了
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {// 还是链表结构，且链表的头元素和要插入的元素的key不一致
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) { // 当前元素是最后一个元素，
                    // 则将新节点放到p的后面
                    p.next = newNode(hash, key, value, null);
                    // 判断后的元素是否达到  TREEIFY_THRESHOLD(8)
                    if (binCount >= TREEIFY_THRESHOLD - 1) 
                        treeifyBin(tab, hash); // 树化操作
                    break;
                }
                // 在链表中找到一个key和当前要插入元素的key一致的元素
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // 找到了要替换的数据， 判断onlyIfAbsent后进行替换数据操作
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

5.1.2 resize方法

// 为什么需要扩容：为了解决哈希冲突导致的链化影响查询效率的问题，通过扩容来缓解
final Node<K,V>[] resize() {
    // oldTab:扩容前的哈希表
    Node<K,V>[] oldTab = table;
    // oldCap:扩容之前的table数组的长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // oldThr:扩容之前的扩容阈值，触发本次扩容的阈值
    int oldThr = threshold;
    // newCap:扩容之后哈希数组的大小
    // newThr:扩容之后，下次再次触发扩容的条件
    int newCap, newThr = 0;
    // 下面if  else 就是计算本次扩容之后 数组的大小newCap, 以及下次再次触发扩容的大小newThr      
    if (oldCap > 0) {
        // 哈希表已经初始化过了，这是一次正常扩容
        if (oldCap >= MAXIMUM_CAPACITY) { // 扩容之前的哈希数组大小已经达到最大阈值了，则不扩容，且设置扩容条件为
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 容量翻倍
            newThr = oldThr << 1; 
    }
    else if (oldThr > 0) // 哈希表还是null，如下情况：1.new HashMap(initCapacity, loadFatory) 2.new HashMap(initCapacity) 3.new HashMap(map)
        newCap = oldThr;
    else {// 哈希表还是null，且 只有 new HashMap()时
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //newThr为0时，通过newCap和loadFactory计算出一个newThr
    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]; // 创建一个更大的数组
    table = newTab;
    if (oldTab != null) { // 说明扩容之前，哈希里面已经有数据了
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) { // 当前哈希数组位置有数据
                oldTab[j] = null; // 置空，方便JVM回收内存
                if (e.next == null) // 当前元素没有和任何数据发生碰撞， 最简单情况
                    newTab[e.hash & (newCap - 1)] = e; // 新计算哈希表的索引将值放进去就行
                else if (e instanceof TreeNode) // 当前节点已树化
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // 链表情况
                    // 低位链表：存放在扩容之后的数组的下标位置，与当前数组的下标位置一致
                    Node<K,V> loHead = null, loTail = null;
                    // 高位链表：存放在扩容之后的数组的下标位置为当前数组的下标位置 + 扩容之前数组的长度
                    Node<K,V> hiHead = null, hiTail = null;
                    
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // hash -> ... 0 1111
                        // oldCap->000 1 0000
                        //       ->000 0 0000   这样就巧妙的分出 loHead和hiHead了
                        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;
}

5.1.3 get方法

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    // tab:当前哈希表的数组
    // first:哈希表数组桶位的头元素
    // e:临时node元素
    // n:哈希表的数组的长度
    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) { // 哈希表不等于空，且要取的数据的key的哈希值在哈希表中存在
        if (first.hash == hash && // 哈希表数组中的头元素就是需要查找的数据，则直接返回
            ((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 { // 循环每个节点判断是否相等，是则返回
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

5.1.4 remove方法

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    //tab:引用哈希表中的数组
    //p:当前Node元素
    //n:哈希表的长度
    //index:寻址结果
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) { // 哈希有数据，且路由到的数组索引也是有数据的，需要进行查找操作并且删除
        // node:查找到的结果
        // e:当前node的下一个节点
        Node<K,V> node = null, e; K k; V v;
        
        if (p.hash == hash && 
            ((k = p.key) == key || (key != null && key.equals(k)))) // 第一种情况 当前数组索引中的元素就是你要删除的元素
            node = p;
        else if ((e = p.next) != null) { // 当前数组索引不是你要删除的元素，且数组索引的头节点后续还有节点，不是树就是链表
            if (p instanceof TreeNode) // 第二种情况 是树
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else { // 第三种情况 链表
                do {// 循环链表查询
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode) // 树 情况删除节点
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p) // 数组头节点是要删除的元素
                tab[index] = node.next;
            else // 链表元素删除 node是p.next
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

public boolean remove(Object key, Object value) {
    return removeNode(hash(key), key, value, true, true) != null;
}

5.1.5 replace方法

// key和oldValue都相同 替换value
public boolean replace(K key, V oldValue, V newValue) {
    Node<K,V> e; V v;
    if ((e = getNode(hash(key), key)) != null &&
        ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
        e.value = newValue;
        afterNodeAccess(e);
        return true;
    }
    return false;
}

// key相同，替换value
public V replace(K key, V value) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) != null) {
        V oldValue = e.value;
        e.value = value;
        afterNodeAccess(e);
        return oldValue;
    }
    return null;
}

5.2 TreeMap

TreeMap继承AbstractMap实现NavigableMap接口，底层是红黑树结构

可以传一个自定义排序器，对元素进行排序，元素的key不能为null

5.3 LinkedHashMap

LinkedHashMap继承HashMap实现Map接口，底层使用哈希表与双向链表来保存所有元素，哈希表使用的是HashMap，双向链表实现是LinkedHashMap重新定义了哈希表的数组中保存元素的Entry，它除了保存当前对象的引用外，还保存了其上一个元素-before和下一个元素-after的引用，从而在哈希标的基础上又构建了双向链表。