Java集合大全

集合也是一种容器，在开发过程中的应用数不胜数，除了常见的HashMap、ArrayList、LinkedList和HashSet等等，了解这些集合API的同时，也应该了解这些集合内部发生了什么事情，这样就不再是集合提供了什么功能给我们用，而是我们选择了它的什么功能。

一、Java集合架构图

1.集合框架提供两个遍历接口：Iterator和ListIterator，后者是前者的优化版，支持在集合任意一个位置进行前后双向遍历;
2.整个集合框架分为两个类型：Collection和Map，前者是一个容器，存储一系列的对象；后者是键值对，存储一系列的键值对;
3.在现有的集合框架体系下，衍生出四种具体集合类型：Map、Set、List、Queue;
4.Map存储键值对，查找元素时通过key查找value;
5.Set内部存储一系列不可重复的对象，且是一个无序集合，对象排列顺序不一;
6.List内部存储一系列可重复的对象，是一个有序集合，对象按插入顺序排列;
7.Queue是一个队列容器，其特性与List相同，但只能从队头和队尾操作元素;
8.JDK 为集合的各种操作提供了两个工具类Collections和Arrays;

9.四种具体类型的集合，内部会再衍生许多不同特性的集合子类，根据不通的应用场景选择使用的集合;

二、集合的迭代器

目前Java里有三个迭代器：Iterator Iterable ListIterator。

1. 首先看Iterator接口：

public interface Iterator {
    boolean hasNext();
    E next();
    void remove();
}

提供的API接口含义如下：
hasNext()：判断集合中是否还有下一个对象。
next()：返回集合中的下一个对象，并将访问指针移动一位。
remove()：删除集合中调用next()方法返回的对象。
在JDK早期版本里，遍历集合的方式只有一种，那就是通过Iterator迭代器操作，具体实例如下：

List list = new ArrayList<>();
list.add(10);
list.add(20);
list.add(30);
Iterator iter = list.iterator();
while (iter.hasNext()) {
    Integer next = iter.next();
    System.out.println(next);
    if (next == 20) {
      iter.remove(); 
    }
}

2. Iterable接口

public interface Iterable {
    Iterator iterator();
    // since JDK 1.8
    default void forEach(Consumer action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    // since JDK 1.8
    default Spliterator spliterator() {
       return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

　Iterable接口里面提供了一个Iterator()方法返回迭代器，因此实现了Iterable接口的集合依旧可以使用迭代器遍历和操作集合中的对象。在 JDK 1.8中，Iterable接口新增了一个方法forEach()，它允许使用增强 for 循环遍历对象。

    为什么要设计两个接口Iterable和Iterator？Iterator接口的保留可以让子类去实现自己的迭代器，而Iterable接口更加关注于for-each的增强语法。

3. ListIterator

　　ListIterator继承 Iterator 接口，仅存在于 List 集合之中，通过调用方法可以返回起始下标为 index的迭代器。ListIterator 中有几个重要方法，大多数方法与 Iterator 中定义的含义相同，此外根据返回的迭代器，且可以实现双向遍历。

public interface ListIterator extends Iterator {
    boolean hasNext();
    E next();
    boolean hasPrevious();
    E previous();
    int nextIndex();
    int previousIndex();
    void remove();
    // 替换当前下标的元素,即访问过的最后一个元素
    void set(E e);
    void add(E e);
}

三、Map和Collection接口

　　Map接口和Collection接口是Java的集合框架中的两个重要门派，Collection存储的是集合元素本身，Map存储的是键值对，但是部分Collection子类使用了Map来实现的。例如：HashSet底层使用了HashMap，TreeSet底层使用了TreeMap，LinkedHashSet底层使用了LinkedHashMap

Map接口的数据结构是形式，key 映射value，一个key对应一个value，key不可重复，value可重复。Map接口细分为不同的种类：

    SortedMap接口：该类映射可以对按照自己的规则进行排序，具体实现有 TreeMap
    AbsractMap抽象类：它为子类提供好一些通用的API实现，所有的具体Map如HashMap都会继承它

Collection接口提供了所有集合的通用方法（注意这里不包括Map）：
    添加方法：add(E e) / addAll(Collection var1)/ addAll(int index, Collection var1)  
    查找方法：contains(Object var1) / containsAll(Collection var1)/
    查询集合自身信息：size() / isEmpty()
    删除方法：remove(O o)/removeAll(Collection var1)/求交集：retainAll(Collection c)

    ... ...

Collection接口将集合细分为不同的种类：

    Set接口：一个不允许存储重复元素的无序集合，具体实现有HashSet / TreeSet···
    List接口：一个可存储重复元素的有序集合，具体实现有ArrayList / LinkedList···
    Queue接口：一个可存储重复元素的队列，具体实现有PriorityQueue / ArrayDeque···

1. Map接口详解

Map 体系下主要分为 AbstractMap 和 SortedMap两类集合
        AbstractMap是对Map接口的扩展，定义了普通Map集合具有的通用方法，可避免子类重复编写大量相同代码，子类继承 AbstractMap 后可重写它的方法，并实现额外逻辑，对外可提供更多的功能。
        SortedMap接口定义了Map具有排序行为，当子类实现它时，必须重写所有方法，对外提供排序功能。

1.1 HashMap

        HashMap 是一个最通用的利用哈希表存储元素的集合，有元素加入HashMap时，会将key的哈希值转换为数组的索引下标确定存放位置，在查找元素时，根据key的哈希地址转换成数组的索引下标确定查找位置。
    HashMap 底层是用数组 + 链表 + 红黑树这三种数据结构实现，是非线程安全的集合。

加入元素发生哈希冲突时，HashMap会将相同地址的元素连成一条链表，若链表长度大于8，且数组长度大于64会转换成红黑树数据结构。

关于 HashMap 的简要总结：
    1. 它是集合中最常用的Map集合类型，底层由数组 + 链表 + 红黑树组成；
    2. HashMap不是线程安全的；
    3. 插入元素时，通过计算元素哈希值，通过哈希映射函数转换为数组下标；查找元素时，通过哈希映射函数得到数组下标定位元素的位置。

1.2 LinkedHashMap

LinkedHashMap可以看作是 HashMap 和 LinkedList 的结合：它是在 HashMap 的基础上添加了一条双向链表，默认存储各个元素的插入顺序，但由于这条双向链表，使得 LinkedHashMap 可以实现 LRU缓存淘汰策略，因为我们可以设置这条双向链表按照元素的访问次序进行排序

// 头节点
transient LinkedHashMap.Entry head;
// 尾结点
transient LinkedHashMap.Entry tail;

利用 LinkedHashMap 可以实现 LRU 缓存淘汰策略，因为它提供了一个方法：

protected boolean removeEldestEntry(java.util.Map.Entry eldest) {
    return false;
}

该方法可以移除最靠近链表头部的一个节点，而在get(key)方法源代码如下，其作用是挪动结点的位置：

public V get(Object key) {
   Node e;
   if ((e = getNode(hash(key), key)) == null)
      return null;
   if (accessOrder)
      afterNodeAccess(e);
   return e.value;
}

只要调用了get(key)且accessOrder = true，则会将该节点更新到链表尾部，具体的逻辑在afterNodeAccess()中，源码如下：

void afterNodeAccess(Node e) { // move node to last
　　LinkedHashMap.Entry last;
　　if (accessOrder && (last = tail) != e) {
　　　　LinkedHashMap.Entry p = (LinkedHashMap.Entry)e, b = p.before, a = p.after;
　　　　p.after = null;
　　　　if (b == null) head = a;
　　　　  else b.after = a;
　　　　if (a != null) a.before = b;
　　　　else last = b;
　　　　if (last == null) head = p;
　　　　else {
　　　　　　p.before = last;
　　　　　　last.after = p;
　　　  }
　　　　tail = p;
　　　　++modCount;
　　}
}

指定accessOrder = true，可以设定链表按照访问顺序排列，通过提供的构造器可以设定accessOrder。

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

重写removeEldestEntry()方法，内部定义逻辑，通常是判断容量是否达到上限，若是则执行淘汰。

关于 LinkedHashMap 总结两点：
    1. 底层维护了一条双向链表，继承了 HashMap，所以不是线程安全的
    2. LinkedHashMap 可实现LRU缓存淘汰策略，其原理是通过设置accessOrder为true并重写removeEldestEntry方法定义淘汰元素时需满足的条件。

1.3 TreeMap

TreeMap 是 SortedMap 的子类，所以它具有排序功能，是基于红黑树数据实现的，每个键值对都是一个结点，默认情况下按照key自然排序，另一种是可以通过传入定制的Comparator进行自定义规则排序。

// 按照 key 自然排序，Integer 的自然排序是升序
TreeMap naturalSort = new TreeMap<>();
// 定制排序，按照 key 降序排序
TreeMap customSort = new TreeMap<>((o1, o2) -> Integer.compare(o2, o1));

图中红黑树的每一个节点都是一个Entry，在这里不标明 key 和 value 了，这些元素都是已按照key排好序了，整个数据结构都是保持着有序状态！
关于自然排序与定制排序：
自然排序：要求key必须实现Comparable接口。
由于Integer类实现了Comparable 接口，按照自然排序规则是按照key从小到大排序。

TreeMap treeMap = new TreeMap<>();
treeMap.put(2, "贰");
treeMap.put(1, "壹");
System.out.print(treeMap);
// {1=壹, 2=贰}

定制排序：在初始化 TreeMap 时传入新的Comparator，不要求key实现 Comparable 接口

TreeMap treeMap = new TreeMap<>((o1, o2) -> Integer.compare(o2, o1));
treeMap.put(1, "壹");
treeMap.put(2, "贰");
treeMap.put(4, "肆");
treeMap.put(3, "叁");
System.out.println(treeMap);
// {4=肆, 3=叁, 2=贰, 1=壹}

关于 TreeMap 主要介绍了三点：
        1. 它底层是由红黑树实现的，操作的时间复杂度为O(logN)；
        2. TreeMap 可以对key进行自然排序或者自定义排序，自定义排序时需要传入Comparator，而自然排序要求key实现了Comparable接口；
        3. TreeMap 不是线程安全的。

1.4 WeakHashMap

        WeakHashMap底层存储的元素的数据结构是数组 + 链表，没有红黑树。日常开发中用的很少，是基于Map实现，Entry中键在每一次垃圾回收都会被清除，适合用于短暂访问或访问一次的元素，缓存在WeakHashMap中，并尽早地把它回收掉。

public class WeakHashMap extends AbstractMap implements Map {
}

　　当Entry被GC时，WeakHashMap 是如何感知到某个元素被回收的呢？

        在 WeakHashMap 内部维护了一个引用队列queue：

private final ReferenceQueue