集合在我们的日常开发中所使用的次数简直太多了，你已经把它们都用的熟透了，但是作为一名合格的程序员，你不仅要了解它的基本用法，你还要了解它的源码；存在即合理，你还要了解它是如何设计和实现的，你还要了解它的衍生过程。

这篇博客就来详细介绍一下 Collection 这个庞大集合框架的家族体系和成员，让你了解它的设计与实现。

是时候祭出这张神图了首先来介绍的就是列表爷爷辈儿的接口- Iterator

01、Iterable 接口

JavaDoc 解释：实现此接口允许对象成为 for-each 循环的目标

也就是说，实现了此接口，就能使用 for-each 进行循环遍历，for-each 是增强型的 for 循环，是 java 提供的一种语法糖，它的基本遍历方式如下：

List<Object> list = new ArrayList();
for (Object obj: list){}

除了实现此接口的对象外，数组也可以用 for-each 循环遍历，如下：

Object[] list = new Object[10];
for (Object obj: list){}

那么，为什么实现了此接口的对象可以进行 for-each 遍历呢？上述的循环遍历经过反编译后如下：

// 数组
Object[] list = new Object[10];
Object[] var14 = list;
int var15 = list.length;

for (int var16 = 0; var16 < var15; ++var16) {
 Object var10000 = var14[var16];
}

// 对象
List<Object> list = new ArrayList();

Object var15;
for (Iterator var14 = list.iterator(); var14.hasNext(); var15 = var14.next()) {
 ;
}

也就是说，for-each 循环经过反编译后，会自动创建 iterator 来实现对数组和对象的循环遍历。

其他遍历方式

jdk1.8 之前Iterator只有 iterator 一个方法，就是

Iterator<T> iterator();

实现次接口的方法能够创建一个轻量级的迭代器，用于安全的遍历元素，移除元素，添加元素。

为什么说是安全的遍历元素，移除元素，添加元素？请参考for 、foreach 、iterator 三种遍历方式的比较[1]

也可以使用迭代器的方式进行遍历

for(Iterator it = coll.iterator(); it.hasNext(); ){
 System.out.println(it.next());
}

本篇先不探讨相关 jdk1.8 的新特性

02、Collection 接口

Collection 位于继承体系的顶级接口，它的上面只有 Iterable 接口，但是 Iterable 和集合的继承体系并无直接关系，我们一说集合框架的顶级接口其实就是指的是 Collection 接口，一说映射的顶级接口就指的是 Map 接口，而 Iterable 接口更多扮演辅助的作用。

Collection 接口更多的是制定标准的作用。它主要指定的标准有

// ArrayList.java
public ArrayList() {...}
public ArrayList(Collection<? extends E> c) {...}

// LinkedList.java
public LinkedList() {}
public LinkedList(Collection<? extends E> c) {...}

// LinkedHashSet.java
public LinkedHashSet() {...}
public LinkedHashSet(Collection<? extends E> c) {...}

// HashSet.java
public HashSet() {...}
public HashSet(Collection<? extends E> c) {...}

// TreeSet.java
public TreeSet() {...}
public TreeSet(Collection<? extends E> c) {...}

个人理解添加 Collection 类型的构造函数其实就是为了集合的复制和集合的相互转化。

List 接口

List 也被称为列表或者有序序列，它继承了 Collection 接口，提供了很多与 Collection 相同的方法，同时也是 ArrayList、LinkedList 等的父类。List 定义了一些列表的标准，它的具体特性如下：

• 使用该接口可以有序的控制每个元素的插入次序，使用者也可以通过索引访问元素，并寻找 list 中的元素。
• 与 set 不同，list 允许重复元素。list 列表中的元素保证插入的次序是因为其存储在 list 中的元素都满足 e1.equals(e2)，并且允许多个空元素。
• List 除了使用 Iterator 作为迭代器之外，还提供了一种特殊的迭代器 ListIterator，是 List 接口所独有的。ListIterator 除了允许正常的操作外，增加了元素的插入和替换，还允许双向访问，提供了一种方法来获得从列表中的指定位置开始的序列迭代器

ListIterator<E> listIterator();
// 从指定位置处开始
ListIterator<E> listIterator(int index);

• List 接口提供了两种方法寻找指定的对象，从性能的角度来看，应谨慎使用这些方法。它们将执行昂贵的线性搜索

int indexOf(Object o);
int lastIndexOf(Object o);

Set 接口

Set 接口位于与 List 接口同级的层次上，它同时也继承了 Collection 接口。

• Set 属于集合框架的一个子类，它不允许重复元素。也就是说，它包含在内的每两个元素的比较都不能满足 e1.equals(e2)，所以最多只允许一个空元素。
• Set 接口提供了额外的规定，超出了从 Collection 接口继承的那些。它对 add,equals,hashCode 方法提供了额外的标准。其他从 Collection 继承下来的方法在这仍然用起来很方便。
• 对于构造函数的约定，也就能理解，所有的构造函数必须构建一个不包含重复元素的集合。
• 注意：如果将可变元素用于 set 对象的集合，则必须非常小心。
• 一些 set 的实现对元素有严格的控制。例如，一些实现禁止空元素，一些实现对元素类型有严格对限制。尝试添加一些不合法的元素会抛出未经检查的异常。特别是 NullPointerException 或者 ClassCastException 。尝试查询不合法的元素也会抛出异常，或者可能仅仅返回 false。一些将展示前者的行为一些将展示后者的行为。大致上来说，尝试对不合格的元素进行操作，其完成的操作不会导致将不合格的元素插入到集合中。在实现中可以选择是当插入不合法元素时抛出异常还是仅仅只返回 false。

Queue 接口

Queue(队列) 是和 List、Set 接口并列的 Collection 的三大接口之一。Queue 的设计用来在处理之前保持元素的访问次序。除了 Collection 基础的操作之外，队列提供了额外的插入，读取，检查操作。这些当中每一个方法都会有两种形式：如果失败就抛出异常，其他方式返回特殊的值(null 或者 false)，后者组成的插入操作被设计成用来严格控制队列容量的实现；在大部分的实现中，插入操作不能直接失败。

Queue 接口提供了几种功能相似但细节不同的方法：

add & offer() , remove() & poll(), element() & peek()

前者失败都会抛出异常，后者会返回特殊的值。

SortedSet 接口

SortedSet 接口直接继承于 Set 接口，提供了一个进一步对元素进行排序的 set。使用 Comparable 对元素进行自然排序或者使用 Comparator 在创建时对元素提供定制的排序规则。set 的迭代器将按升序元素顺序遍历集合。

• 一个 void（无参数）构造函数，它根据元素的自然顺序创建一个空的有序集。
• 一个创建了单个 Comparator 类型参数的构造函数，它创建一个根据指定比较器排序的空排序集
• 一个创建了单个 Comparator 类型参数的构造函数，它创建一个新的有序集合，其元素与其参数相同，并根据元素的自然顺序进行排序
• 一个创建了单个 SortedSet 类型参数的构造器，它创建了一个新的有序集，其元素和输入有序集的顺序相同。由于接口不能包含构造函数，因此无法强制执行。

AbstractCollection 抽象类

AbstractCollection 这个接口是 Collection 接口的一个核心实现，采用抽象方法提供部分代码的实现，用来简化实现此接口所需要的工作量，此接口提供了一些对于实现类的说明，并提供了一系列标准。

• 为了实现不可修改的 collection，程序员应该继承这个类并提供 iterator 和 size 方法(迭代器需要实现 hasNext() 和 next() 方法)
• 为了实现可修改的 collection，程序员需要额外重写类的 add 方法，iterator 方法返回的 Iterator 迭代器也必须实现 remove 方法

AbstractList 抽象类

AbstractList 接口位于中间层，向下是具体的实现类，向上是定义的抽象标准，AbstractList 继承了AbstractCollection 并实现了**List **接口，具体继承体系见下图AbstractCollection 继承体系

此接口也是 List 继承类层次的核心接口，以求最大限度的减少实现此接口的工作量，由顺序访问数据存储(数组)支持。对于序列访问的数据(像是链表)，应该优先使用 AbstractSequentialList。

ArrayList 类

ArrayList 是实现了 List 接口的可扩容数组(动态数组)，它的内部是基于数组实现的。它的具体定义如下：

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {...}

List list = Collections.synchronizedList(new ArrayList(...))

更多关于 ArrayList 的用法，请参考ArrayList 相关方法介绍及源码分析[2]

Vector 类

Vector 类实现了可增长的对象数组。像数组一样，它包含可以使用整数索引访问元素。但是，Vector 的大小可以根据需要增大或减小，以便在创建 Vector 后添加和删除。

• 每一个 vector 都试图去维护 capacity 和 capacityIncrement 来优化内部存储。capacity 总是要保持和 vector 一样的大小。随着新元素的增加，它的容量也在一直变大。vector 的存储以 capacityIncrement 的大小增加。应用程序可以在插入大量元素之前增加 vector 的容量，这就会减少重新分配的次数，降低重新分配带来的影响。
• 这个类 iterator() 方法和 listIterator() 方法返回的 iterators 是有快速失败机制的：如果 vector 在创建了 iterator 之后经过了结构化的修改，除了调用迭代器内部的 remove 或者 add 方法之外的其他方法，都会抛出 ConcurrentModificationException
• elements 方法返回的 Enumeration 则没有 fail-fast 机制。

Stack 堆栈类

Stack 类代表了后进先出 (LIFO) 对象的堆栈。它继承了 Vector 类，并且有五个操作允许 vector 像 stack 一样看待。提供了通常用的 push 和 pop 操作，以及在栈顶的 peek 方法，测试 stack 是否为空的 empty 方法，和一个寻找与栈顶距离的 search 方法。

第一次创建栈，不包含任何元素。一个更完善，可靠性更强的 LIFO 栈操作由 Deque 接口和他的实现提供，应该优先使用这个类

Deque<Integer> stack = new ArrayDeque<Integer>()

AbstractSet 抽象类

继承体系和 AbstractList 基本相同，除了 AbstractList 实现了 List 接口，而 AbstractSet 实现了 Set 接口。

• AbstractSet 是 Set 接口的骨干实现，以求最大限度的减少实现此接口的工作量。
• 通过扩展此类来实现集合的过程与通过扩展 AbstractCollection 实现集合的过程相同。除了这个类的子类中的所有方法和构造函数必须遵守 Set 接口强加的附加约束（例如，add 方法不允许将对象的多个实例添加到集合中）
• 注意这个类没有重写任何 AbstractCollection 的实现，它仅仅增加了 equals 和 hashCode 实现。

HashSet 类

HashSet 类是 Set 接口的实现类，由哈希表支持(实际上 HashSet 是 HashMap 的一个实例)。它不能保证集合的迭代顺序；特别是，它不保证顺序会随着时间的推移保持不变(也就是无序的)。这个类允许 null 元素。

• 这个类为基本操作 (add,remove,contains,size) 提供恒定的时间和性能，假设 hash 功能在桶之间正确的分散元素迭代此 set 需要的时间与 HashSet 实例大小(元素的数量)加上 HashMap 实例的 capacity (桶的数量)是成正比。因此，如果迭代性能很重要的话，那么不要设置初始 capacity 太高(或者负载因子太低)是很重要的。
• 注意这个实现不是线程安全的。如果多线程并发访问 HashSet ，并且至少一个线程修改了 set ，必须进行外部加锁。这通常通过在自然封装集合的某个对象上进行同步来实现
• 如果没有这个对象存在，这个 set 应该使用 Collections.synchronizedSet 方法重写。最好在创建时这么做，以防止对集合的意外不同步访问
• 这个实现持有 fail-fast 机制。

TreeSet 类

TreeSet 类是一个基于 TreeMap 的 NavigableSet 实现。这些元素使用他们的自然排序或者在创建时提供的 Comparator 进行排序，具体取决于使用的构造函数。

• 此实现为基本操作 add,remove 和 contains 提供了 log(n) 的时间成本。
• 注意这个实现不是线程安全的。如果多线程并发访问 TreeSet ，并且至少一个线程修改了 set ，必须进行外部加锁。这通常通过在自然封装集合的某个对象上进行同步来实现
• 如果没有这个对象存在，这个 set 应该使用

SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...))

方法重写。最好在创建时这么做，以防止对集合的意外不同步访问

LinkedHashSet 类

LinkedHashSet 类继承于 Set，先来看一下 LinkedHashSet 的继承体系：

LinkedHashSet 是 Set 接口的 Hash 表和 LinkedList 的实现，具有可预测的迭代次序。这个实现不同于 HashSet 的是它维护着一个贯穿所有条目的双向链表。此链表定义了元素插入集合的顺序。注意：如果元素重新插入，则插入顺序不会受到影响。

• 此实现免受 HashSet 混乱的排序。但不会导致像 TreeSet 相关的开销增加。无论原始集的实现如何，它都可用于生成与原始集合具有相同顺序的集合的副本：

void foo(Set s) {
 	Set copy = new LinkedHashSet(s);
}

AbstractQueue 抽象类

这个类是 Queue 接口的骨干实现，当实现不允许为 null 元素时，使用此类中的实现是比较合适的。add, remove, element 是基于 offer, poll 和 peek 方法的。扩展此类 Queue 实现必须最低开销的定义一个方法 Queue.offer，该方法不允许插入 null 元素，以及方法 peek，poll，size，iterator。通常，还会覆盖其他方法。如果无法满足这些要求，请考虑用继承替代。

PriorityQueue 类

PriorityQueue 是 AbstractQueue 的实现类，优先级队列的元素根据自然排序或者通过在构造函数时期提供 Comparator 来排序，具体根据构造器判断。一个优先级队列不允许 null 元素依赖于自然排序的优先级队列也不允许插入不可比较的对象（这样做可能导致 ClassCastException ）。

AbstractSequentialList 抽象类

AbstractSequentialList 是 List 一系列子类接口的核心接口，以求最大限度的减少实现此接口的工作量，由顺序访问数据存储(例如链接链表)支持。对于随机访问的数据(像是数组)，应该优先使用 AbstractList。

• 在这个概念上，这个接口可以说是与 AbstractList 类相反的，它实现了随机访问方法，提供了 get(int index), set(int index,E element), add(int index,E element) 和 remove(int index) 方法在列表的迭代器上
• 要实现一个列表，程序员只需要扩展这个类并且提供 listIterator 和 size 方法即可。对于不可修改的列表来说， 程序员需要实现列表迭代器的 hasNext(), next(), hasPrevious(), previous() 和 index() 方法
• 对于允许修改的 list，程序员应该额外实现 list 迭代器的 set 方法，对于可变大小的列表，程序员应该额外实现迭代器的 r emove 方法 和 add 方法

LinkedList 类

LinkedList 是一个双向链表，实现了所有 List 列表的可选择性操作，允许存储任何元素(包括 null 值)。它的主要特性如下：

• LinkedList 所有的操作都可以表现为双向性的，索引到链表的操作将遍历从头到尾，视哪个距离近为遍历顺序。
• 注意这个实现也不是线程安全的，如果多个线程并发访问链表，并且至少其中的一个线程修改了链表的结构，那么这个链表必须进行外部加锁。(结构化的操作指的是任何添加或者删除至少一个元素的操作，仅仅对已有元素的值进行修改不是结构化的操作)。
• 如果没有这样的链表存在，这个链表应该用 Collections.synchronizedList 方法进行包装，最好在创建时间就这样做，避免意外的非同步对链表的访问

List list = Collections.synchronizedList(new LinkedList(...))

Iterator 和 listIterator 都会返回 iterators，并且都是支持 fail-fast 机制的。如果创建后再进行结构化修改的话，除了通过迭代器自己以外的任何方式，都会抛出 ConcurrentModificationException 。因此，面对并发修改的情况，iterator 能够快速触发 fail-fast 机制，而不是冒着潜在的风险。

更多关于 LinkedList 的用法，请参考

LinkedList 基本示例及源码解析[3]

03、Map 接口

Map 是一个支持 key-value 存储的对象，Map 不能包含重复的 key，每个键最多映射一个值。这个接口代替了 Dictionary 类，Dictionary 是一个抽象类而不是接口。

• Map 接口提供了三个集合的片段，它允许将 map 的内容视为一组键，值的集合和一组 key-value 映射。map 的顺序定义为 map 映射集合上的迭代器返回其元素的顺序。一些 map 实现，像是 TreeMap 类，保证了 map 的次数；其他的实现，像是 HashMap，则没有保证。
• 一般用途的 map 实现类应该提供两个标准的构造器：一个空 map 创建一个 void (无参数)构造器。和一个只有单个 Map 类型参数的构造器。后者的构造器允许用户复制任意 map，生成所需类的有效映射。无法强制执行此建议(因为接口不能包含构造器)但 JDK 中的所有通用映射实现都符合要求。
• 一些 map 实现包含在内的对键和值有限制例如，一些实现禁止 null keys 和 values，一些实现对 keys 的类型有限制。尝试插入不合格的键或值会引发未经检查的异常，比如 NullPointerException 或者 ClassCastException 尝试查询不合格的 key 或 value 也可能抛出异常，或者可能返回 false；一些实现允许前者的行为，一些实现允许后者的行为

AbstractMap 抽象类

这个抽象类是 Map 接口的骨干实现，以求最大化的减少实现类的工作量。

• 为了实现不可修改的 map，程序员仅需要继承这个类并且提供 entrySet 方法的实现，它将会返回一组 map 映射的某一段。通常，返回的集合将在 AbstractSet 之上实现。这个 set 不应该支持 add 或者 remove 方法，并且它的迭代器也不支持 remove 方法。
• 为了实现可修改的 map，程序员必须额外重写这个类的 put 方法(否则就会抛出 UnsupportedOperationException)，并且 entrySet.iterator() 返回的 iterator 必须实现 remove() 方法。
• 程序员应该提供一个无返回值(无参数)的 map 构造器，

HashMap 类

哈希表基于 Map 接口的实现，这个实现提供可选择的 map，并且允许空 value 值和空 key，可以认为 HashMap 是 Hashtable 的增强版，可以认为 HashMap 不是可同步的(非线程安全)和允许空值外，可以认为 HashMap 顺序性，也就是说，它不能保证其内部的顺序一成不变

Map m = Collections.synchronizedMap(new HashMap());

• 支持 fail-fast 快速失败机制

TreeMap 类

一个基于 NavigableMap 实现的红黑树。这个 map 根据 key 自然排序存储，或者通过 Comparator 基于 NavigableMap 实现的红黑树。这个 map 根据 key 自然排序存储，或者通过 Comparator 进行定制排序

SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...))

方法重写。最好在创建时这么做，以防止对集合的意外不同步访问

LinkedHashMap 类

LinkedHashMap 是 map 接口的哈希表和链表的实现，具有可预测的迭代顺序。这个实现与 HashMap 不同之处在于它维护了一个贯穿其所有条目的双向链表。这个链表定义了遍历顺序，通常是插入 map 中的顺序。注意重新插入并不会影响其插入的顺序。如果在 containsKey(k) 时调用 m.put(k,v)，则将 key 插入到 map 中会在调用之前返回 true。

• 此实现使其客户端免受 HashMap, Hashtable 未指定的，混乱的排序。而不会导致像 TreeMap 一样的性能开销，无论原始 map 的实现如何，它都可用于生成与原始 map 具有相同顺序的 map 副本。

void foo(Map m) {
 Map copy = new LinkedHashMap(m);
}

如果没有这个对象存在，这个 set 应该使用

Map m = Collections.synchronizedMap(new LinkedHashMap(...))

方法重写。最好在创建时这么做，以防止对集合的意外不同步访问

• 这个实现持有 fail-fast 机制。

Hashtable 类

Hashtable 类实现了一个哈希表，能够将键映射到值。任何非空对象都可以用作键或值。

// 放置元素
Hashtable<String, Integer> numbers = new Hashtable<String, Integer>();
numbers.put("one", 1);
numbers.put("two", 2);
numbers.put("three", 3);

// 取出元素
Integer n = numbers.get("two");
if(n != null){
 System.out.println("two = " + n);
}

IdentityHashMap 类

IdentityHashMap 是比较小众的 Map 实现了，它使用哈希表实现 Map 接口，在比较键和值时使用引用相等性替换对象相等性。换句话说，在 IdentityHashMap 中两个 key，k1 和 k2 当且仅当 k1 == k2 时被认为是相等的。(在正常的 Map 实现中(类似 HashMap)，两个键 k1 和 k2 当且仅当 k1 == null ? k2 == null : k1.equals(k2)时 被认为时相等的

• 这个类不是一个通用的 Map 实现！虽然这个类实现了 Map 接口，但它故意违反了 Map 的约定，该约定要求在比较对象时使用 equals 方法，此类仅适用于需要引用相等语义的极少数情况。
• 此类提供所有可选择的 map 操作，并且允许 null 值和 null key。这个类不保证 map 的顺序，特别的，它不保证顺序会随着时间的推移保持不变。
• 同 HashMap，IdentityHashMap 也是无序的，并且该类不是线程安全的，如果要使之线程安全，可以调用 Collections.synchronizedMap(new IdentityHashMap(…))方法来实现。
• 支持 fail-fast 机制

WeakHashMap 类

WeakHashMap 类基于哈希表的 Map 基础实现，带有弱键。WeakHashMap 中的 entry 当不再使用时还会自动移除。更准确的说，给定 key 的映射的存在将不会阻止 key 被垃圾收集器丢弃。

相关更详细的 WeakHashMap 解析，见下面这篇文章 http://ifeve.com/weakhashmap/

SortedMap 抽象类

SortedMap 是一个提供了在 key 上全部排序的 map。这个 map 根据 key 的 Comparable 自然排序，提供了在创建时期的 map 排序。遍历有序映射的集合片段(由

entrySet、keySet 和 values 方法返回)时能够反应此顺序的影响。

• 一个无返回值(无参数)的构造器，它根据 key 的自然排序创建类一个空 sorted map。
• 一个有单个 Comparator 类型参数的构造函数，它根据指定比较器创建了一个空的 sorted map 排序。
• 一个有单个 map 类型参数的构造函数，它创建了一个相同 key-value 映射参数的 map，根据 key 来自然排序。
• 一个有单个 SortedMap 类型的构造器，它创建了一个新的有序映射，其具有相同的键 – 值映射和与输入有序映射相同的顺序。

04、Comparable && Comparator

具体描述请详见Comparable 和 Comparator 的理解[5]

05、Collections 类

Collections 不属于 Java 框架继承树上的内容，它属于单独的分支，Collections 是一个包装类，它的作用就是为集合框架提供某些功能实现，此类只包括静态方法操作或者返回 collections。

同步包装

同步包装器将自动同步（线程安全性）添加到任意集合。六个核心集合接口（ Collection，Set，List，Map，SortedSet 和 SortedMap）中的每一个都有一个静态工厂方法。

public static Collection synchronizedCollection(Collection c);
public static Set synchronizedSet(Set s);
public static List synchronizedList(List list);
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);
public static SortedSet synchronizedSortedSet(SortedSet s);
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m);

不可修改的包装

不可修改的包装器通过拦截修改集合的操作并抛出 UnsupportedOperationException，主要用在下面两个情景：

• 构建集合后使其不可变。在这种情况下，最好不要去获取返回 collection 的引用，这样有利于保证不变性
• 允许某些客户端以只读方式访问你的数据结构。你保留对返回的 collection 的引用，但分发对包装器的引用。通过这种方式，客户可以查看但不能修改，同时保持完全访问权限。

这些方法是：

public static Collection unmodifiableCollection(Collection<? extends T> c);
public static Set unmodifiableSet(Set<? extends T> s);
public static List unmodifiableList(List<? extends T> list);
public static <K,V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m);
public static SortedSet unmodifiableSortedSet(SortedSet<? extends T> s);
public static <K,V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, ? extends V> m);

线程安全的 Collections

Java1.5 并发包 (java.util.concurrent) 提供了线程安全的 collections 允许遍历的时候进行修改，通过设计 iterator 为 fail-fast 并抛出 ConcurrentModificationException。一些实现类是CopyOnWriteArrayList，ConcurrentHashMap，CopyOnWriteArraySet

Collections 算法

此类包含用于集合框架算法的方法，例如二进制搜索，排序，重排，反向等。

有兴趣的读者可以阅读https://docs.oracle.com/javase/tutorial/collections/algorithms/ 本篇暂不探讨算法问题。

06、Arrays 类

这个类包含各种各样的操作数组的方法(例如排序和查找)。这个类也包含一个静态工厂把数组当作列表来对待。如果指定数组的引用为 null，这个类中的方法都会抛出 NullPointerException，除非有另外说明。

详细的用法请参考JAVA 基础——Arrays 工具类十大常用方法[6]

07、集合实现类特征图

下图汇总了部分集合框架的主要实现类的特征图，让你能有清晰明了看出每个实现类之间的差异性

08、相关集合的面试题

碍于篇幅的原因，这里就不贴出来具体的面试题和答案了，大家可以私信我【集合面试题】免费获得。

参考资料

[1]for 、foreach 、iterator 三种遍历方式的比较: https://www.cnblogs.com/cxuanBlog/p/10927538.html

[2]ArrayList相关方法介绍及源码分析: https://www.cnblogs.com/cxuanBlog/p/10949552.html

[3]LinkedList 基本示例及源码解析: https://www.cnblogs.com/cxuanBlog/p/10952578.html

[4]图解集合6：LinkedHashMap: https://www.cnblogs.com/xrq730/p/5052323.html

[5]Comparable 和 Comparator的理解: https://www.cnblogs.com/cxuanBlog/p/10927495.html

[6]JAVA基础——Arrays工具类十大常用方法: https://www.cnblogs.com/hysum/p/7094232.html

原创：cxuan

转自：Java极客技术