集合总体框架及各类型详细解析

一、集合总体框架

二、各集合类型解析

Collection

Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作：添加、删除、清空、遍历(读取)、是否为空、获取大小、是否保护某元素等等。Collection包含了List和Set两大分支。
1.List是一个有序的队列，每一个元素都有它的索引。第一个元素的索引值是0。 List的实现类有LinkedList, ArrayList, Vector, Stack。

2.Set是一个不允许有重复元素的集合。Set的实现类有HastSet和TreeSet。HashSet依赖于HashMap，它实际上是通过HashMap实现的；TreeSet依赖于TreeMap，它实际上是通过TreeMap实现的。

Map

Map是一个映射接口，即key-value键值对。Map中的每一个元素包含“一个key”和“key对应的value”。AbstractMap是个抽象类，它实现了Map接口中的大部分API。而HashMap，TreeMap，WeakHashMap都是继承于AbstractMap。Hashtable虽然继承于Dictionary，但它实现了Map接口。

Iterator

Iterator是遍历集合的工具，即我们通常通过Iterator迭代器来遍历集合。我们说Collection依赖于Iterator，是因为Collection的实现类都要实现iterator()函数，返回一个Iterator对象。ListIterator是专门为遍历List而存在的。

Enumeration

Enumeration是JDK 1.0引入的抽象类。作用和Iterator一样，也是遍历集合；但是Enumeration的功能要比Iterator少。在上面的框图中，Enumeration只能在Hashtable, Vector, Stack中使用。

Arrays\Collections

Arrays和Collections是操作数组、集合的两个工具类。

List

List是一个继承于Collection的接口，即List是集合中的一种。List是有序的队列，List中的每一个元素都有一个索引；第一个元素的索引值是0，往后的元素的索引值依次+1。和Set不同，List中允许有重复的元素。List的API中主要有“添加、删除、获取、修改指定位置的元素”、“获取List中的子队列”等。

Set

Set是一个继承于Collection的接口，即Set也是集合中的一种。Set是没有重复元素的集合。

AbstractCollection

1.AbstractCollection是一个抽象类，它实现了Collection中除iterator()和size()之外的函数。

2.AbstractCollection的主要作用：它实现了Collection接口中的大部分函数。从而方便其它类实现Collection，比如ArrayList、LinkedList等，它们这些类想要实现Collection接口，通过继承AbstractCollection就已经实现了大部分的接口了。

AbstractList

1.AbstractList是一个继承于AbstractCollection，并且实现List接口的抽象类。它实现了List中除size()、get(int location)之外的函数。

2.AbstractList的主要作用：它实现了List接口中的大部分函数。从而方便其它类继承List。另外，和AbstractCollection相比，AbstractList抽象类中，实现了iterator()接口。

AbstractSet

1.AbstractSet是一个继承于AbstractCollection，并且实现Set接口的抽象类。由于Set接口和Collection接口中的API完全一样，Set也就没有自己单独的API。和AbstractCollection一样，它实现了List中除iterator()和size()之外的函数。

2.AbstractSet的主要作用：它实现了Set接口中的大部分函数。从而方便其它类实现Set接口。

Iterator

Iterator是一个接口，它是集合的迭代器。集合可以通过Iterator去遍历集合中的元素。Iterator提供的API接口，包括：是否存在下一个元素、获取下一个元素、删除当前元素。注意：Iterator遍历Collection时，是fail-fast机制的。即，当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛ConcurrentModificationException异常，产生fail-fast事件。

ListIterator

ListIterator是一个继承于Iterator的接口，它是队列迭代器。专门用于便利List，能提供向前/向后遍历。相比于Iterator，它新增了添加、是否存在上一个元素、获取上一个元素等等API接口。

ArrayList

1.ArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

2.和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

3.ArrayList包含了两个重要的对象：elementData 和 size。elementData 是"Object[]类型的数组"，它保存了添加到ArrayList中的元素。实际上，elementData是个动态数组，我们能通过构造函数 ArrayList(int initialCapacity)来执行它的初始容量为initialCapacity；如果通过不含参数的构造函数ArrayList()来创建ArrayList，则elementData的容量默认是10。elementData数组的大小会根据ArrayList容量的增长而动态的增长，当ArrayList容量不足以容纳全部元素时，ArrayList会重新设置容量：新的容量=原容量*1.5 + 1；size 则是动态数组的实际大小。

4.ArrayList支持3种遍历方式。1.通过迭代器遍历；2.随机访问，通过索引值去遍历。3.for循环遍历。遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低！

--迭代器遍历
Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
    value = (Integer)iter.next();
}
--随机访问遍历
Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
    value = (Integer)list.get(i);        
}
--For循环遍历
Integer value = null;
for (Integer integ:list) {
    value = integ;
}

5.当我们调用ArrayList中的 toArray()，可能遇到过抛出“java.lang.ClassCastException”异常的情况。toArray() 会抛出异常是因为 toArray() 返回的是 Object[] 数组，将 Object[] 转换为其它类型(如如，将Object[]转换为的Integer[])则会抛出“java.lang.ClassCastException”异常，因为Java不支持向下转型。

fail-fast

1.fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。产生fail-fast事件，是通过抛出ConcurrentModificationException异常来触发的。ConcurrentModificationException是在操作Iterator时抛出的异常。当多个线程对同一个集合进行操作的时候，某线程访问集合的过程中，该集合的内容被其他线程所改变(即其它线程通过add、remove、clear等方法，改变了modCount的值)；这时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。

2.解决fail-fast机制的办法可以通过使用CopyOnWriteArrayList集合类。

LinkedList

1.LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。bstractSequentialList 只支持按次序访问，而不像AbstractList那样支持随机访问。而AbstractSequentialList 又实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数，这些接口都是随机访问List的。LinkedList既然继承于AbstractSequentialList，就相当于已经实现了“get(int index)这些接口”。LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。LinkedList 实现 List 接口，能对它进行队列操作。LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

2.LinkedList包含两个重要的成员：header 和 size。header是双向链表的表头，它是双向链表节点所对应的类Entry的实例。Entry中包含成员变量： previous, next, element。其中，previous是该节点的上一个节点，next是该节点的下一个节点，element是该节点所包含的值。size是双向链表中节点的个数。

3.LinkedList实际上是通过双向链表去实现的。既然是双向链表，那么它的顺序访问会非常高效，而随机访问效率比较低。既然LinkedList是通过双向链表的？实际原理非常简单，它就是通过一个计数索引值来实现的。例如，当我们调用get(int location)时，首先会比较“location”和“双向链表长度的1/2”；若前者大，则从链表头开始往后查找，直到location位置；否则，从链表末尾开始先前查找，直到location位置。

4.由于LinkedList实现了Deque，LinkedList可以作为FIFO(先进先出)的队列，LinkedList也可以作为LIFO(后进先出)的栈。

5.第一种，通过迭代器遍历。即通过Iterator去遍历。第二种，通过快速随机访问遍历LinkedList。第三种，通过for循环来遍历LinkedList。第四种，通过pollFirst()来遍历LinkedList。第五种，通过pollLast()来遍历LinkedList。第六种，通过removeFirst()来遍历LinkedList。第七种，通过removeLast()来遍历LinkedList。遍历LinkedList时，使用removeFist()或removeLast()效率最高。但用它们遍历时，会删除原始数据；若单纯只读取，而不删除，应该使用第三种遍历方式。

4.LinkedList 是非同步的。LinkedList没有容量限制的。

Vector

1.继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口，和ArrayList不同，Vector中的操作是线程安全的。

2.Vector的数据结构和ArrayList差不多，它包含了3个成员变量：elementData , elementCount， capacityIncrement（扩容系数）。Vector实际上是通过一个数组去保存数据的。当我们构造Vecotr时；若使用默认构造函数，则Vector的默认容量大小是10。 当Vector容量不足以容纳全部元素时，Vector的容量会增加。若容量增加系数 >0，则将容量的值增加“容量增加系数”；否则，将容量大小增加一倍。

3.Vector支持4种遍历方式。第一种，通过迭代器遍历。即通过Iterator去遍历。第二种，随机访问，通过索引值去遍历。第三种，for循环。第四种，Enumeration遍历。遍历Vector，使用索引的随机访问方式最快，使用迭代器最慢。

Stack

1.Stack是栈。它的特性是：先进后出(FILO, First In Last Out)。Stack是继承于Vector(矢量队列)的，由于Vector是通过数组实现的，这就意味着，Stack也是通过数组实现的，而非链表。

2.执行push时(即将元素推入栈中)，是通过将元素追加的数组的末尾中。执行peek时(即，取出栈顶元素，不执行删除)，是返回数组末尾的元素。 执行pop时(即，取出栈顶元素，并将该元素从栈中删除)，是取出数组末尾的元素，然后将该元素从数组中删除。

3. Stack继承于Vector，意味着Vector拥有的属性和功能，Stack都拥有。

Map

1.Map 是映射接口，Map中存储的内容是键值对(key-value)。

2.AbstractMap 是继承于Map的抽象类，它实现了Map中的大部分API。其它Map的实现类可以通过继承AbstractMap来减少重复编码。

3.SortedMap 是继承于Map的接口。SortedMap中的内容是排序的键值对，排序的方法是通过比较器(Comparator)。

4.NavigableMap 是继承于SortedMap的接口。相比于SortedMap，NavigableMap有一系列的导航方法；如"获取大于/等于某对象的键值对"、“获取小于/等于某对象的键值对”等等。

5.TreeMap 继承于AbstractMap，且实现了NavigableMap接口；因此，TreeMap中的内容是“有序的键值对”！

6.HashMap 继承于AbstractMap，但没实现NavigableMap接口；因此，HashMap的内容是“键值对，但不保证次序”！

7.Hashtable 虽然不是继承于AbstractMap，但它继承于Dictionary(Dictionary也是键值对的接口)，而且也实现Map接口；因此，Hashtable的内容也是“键值对，也不保证次序”。但和HashMap相比，Hashtable是线程安全的，而且它支持通过Enumeration去遍历.

8.WeakHashMap 继承于AbstractMap。它和HashMap的键类型不同，WeakHashMap的键是“弱键”。

9.Map提供接口分别用于返回 键集、值集或键-值映射关系集。entrySet()用于返回键-值集的Set集合；keySet()用于返回键集的Set集合；values()用户返回值集的Collection集合；因为Map中不能包含重复的键；每个键最多只能映射到一个值。所以，键-值集、键集都是Set，值集时Collection。

SortedMap

1.SortedMap是一个继承于Map接口的接口。它是一个有序的SortedMap键值映射。

2.SortedMap的排序方式有两种：自然排序 或者 用户指定比较器。 插入有序 SortedMap 的所有元素都必须实现 Comparable 接口（或者被指定的比较器所接受）。

NavigableMap

NavigableMap除了继承SortedMap的特性外，它的提供的功能可以分为4类：

1.提供操作键-值对的方法。lowerEntry、floorEntry、ceilingEntry 和 higherEntry 方法，它们分别返回与小于、小于等于、大于等于、大于给定键的键关联的 Map.Entry 对象。FirstEntry、pollFirstEntry、lastEntry 和 pollLastEntry 方法，它们返回和/或移除最小和最大的映射关系（如果存在），否则返回 null。

2.提供操作键的方法。这个和第1类比较类似lowerKey、floorKey、ceilingKey 和 higherKey 方法，它们分别返回与小于、小于等于、大于等于、大于给定键的键。
3.获取键集。navigableKeySet、descendingKeySet分别获取正序/反序的键集。

4.获取键-值对的子集。

HashMap

1.HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

2.HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。

3.HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。此外，HashMap中的映射不是有序的。

4.HashMap的默认初始容量为16，当时也可以指定初始容量，加载因子是0.75，扩容量为2N。为什么扩容因子是0.75，主要是为了提高空间利用率和减少查询成本的折中，主要是泊松分布，0.75的话碰撞最小。

5.HashMap是通过"拉链法"实现的哈希表。它包括几个重要的成员变量：table, size, threshold, loadFactor, modCount。table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。哈希表的"key-value键值对"都是存储在Entry数组中的。size是HashMap的大小，它是HashMap保存的键值对的数量。threshold是HashMap的阈值，用于判断是否需要调整HashMap的容量。threshold的值="容量*加载因子"，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。loadFactor就是加载因子。modCount是用来实现fail-fast机制的。

6.遍历HashMap的键值对，第一步：根据entrySet()获取HashMap的“键值对”的Set集合。第二步：通过Iterator迭代器遍历“第一步”得到的集合。

Hashtable

1.和Hashmap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。

2.Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。

3.Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。

4.HashTable的默认初始容量为11，当时也可以指定初始容量，加载因子是0.75，扩容量为2N+1。为什么扩容因子是0.75，主要是为了提高空间利用率和减少查询成本的折中，主要是泊松分布，0.75的话碰撞最小。

5.Hashtable继承于Dictionary类，实现了Map接口。Map是"key-value键值对"接口，Dictionary是声明了操作"键值对"函数接口的抽象类。Hashtable是通过"拉链法"实现的哈希表。它包括几个重要的成员变量：table, count, threshold, loadFactor, modCount。table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。哈希表的"key-value键值对"都是存储在Entry数组中的。count是Hashtable的大小，它是Hashtable保存的键值对的数量。threshold是Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。loadFactor就是加载因子。modCount是用来实现fail-fast机制的

6.Hashtable中的elements() 的作用是返回“所有value”的枚举对象。

Treemap

1.TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。TreeMap 实现了Cloneable接口，意味着它能被克隆。TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。

2.TreeMap基于红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。

3.TreeMap是非同步的。 它的iterator 方法返回的迭代器是fail-fastl的。

4.TreeMap实现继承于AbstractMap，并且实现了NavigableMap接口。TreeMap的本质是R-B Tree(红黑树)，它包含几个重要的成员变量： root, size, comparator。root 是红黑数的根节点。它是Entry类型，Entry是红黑数的节点，它包含了红黑数的6个基本组成成分：key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)。Entry节点根据key进行排序，Entry节点包含的内容为value。红黑数排序时，根据Entry中的key进行排序；Entry中的key比较大小是根据比较器comparator来进行判断的。size是红黑数中节点的个数。

WeakHashMap

1.WeakHashMap 继承于AbstractMap，实现了Map接口。

2.和HashMap一样，WeakHashMap 也是一个散列表，它存储的内容也是键值对(key-value)映射，而且键和值都可以是null。不过WeakHashMap的键是“弱键”。在 WeakHashMap 中，当某个键不再正常使用时，会被从WeakHashMap中被自动移除。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为可终止的，被终止，然后被回收。某个键被终止时，它对应的键值对也就从映射中有效地移除了。这个“弱键”的原理呢？大致上就是，通过WeakReference和ReferenceQueue实现的。 WeakHashMap的key是“弱键”，即是WeakReference类型的；ReferenceQueue是一个队列，它会保存被GC回收的“弱键”。实现步骤是：
第一步:新建WeakHashMap，将“键值对”添加到WeakHashMap中,实际上，WeakHashMap是通过数组table保存Entry(键值对)；每一个Entry实际上是一个单向链表，即Entry是键值对链表;第二步:当某“弱键”不再被其它对象引用，并被GC回收时。在GC回收该“弱键”时，这个“弱键”也同时会被添加到ReferenceQueue(queue)队列中;第三步:当下一次我们需要操作WeakHashMap时，会先同步table和queue。table中保存了全部的键值对，而queue中保存被GC回收的键值对；同步它们，就是删除table中被GC回收的键值对。这就是“弱键”如何被自动从WeakHashMap中删除的步骤了。

3.和HashMap一样，WeakHashMap是不同步的。

4.WeakHashmap的默认初始容量为16，当时也可以指定初始容量，加载因子是0.75，扩容量为2N。为什么扩容因子是0.75，主要是为了提高空间利用率和减少查询成本的折中，主要是泊松分布，0.75的话碰撞最小。

5.WeakHashMap继承于AbstractMap，并且实现了Map接口。WeakHashMap是哈希表，但是它的键是"弱键"。WeakHashMap中保护几个重要的成员变量：table, size, threshold, loadFactor, modCount, queue。table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。哈希表的"key-value键值对"都是存储在Entry数组中的。size是Hashtable的大小，它是Hashtable保存的键值对的数量。threshold是Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。loadFactor就是加载因子。modCount是用来实现fail-fast机制的。queue保存的是“已被GC清除”的“弱引用的键”。

HashSet

1.HashSet 是一个没有重复元素的集合。它是由HashMap实现的，不保证元素的顺序，而且HashSet允许使用 null 元素。

2.HashSet是非同步的。

3.HashSet通过iterator()返回的迭代器是fail-fast的。

TreeSet

1.TreeSet 是一个有序的集合，它的作用是提供有序的Set集合。它继承于AbstractSet抽象类，实现了NavigableSet<E>, Cloneable, java.io.Serializable接口。TreeSet 继承于AbstractSet，所以它是一个Set集合，具有Set的属性和方法。TreeSet 实现了NavigableSet接口，意味着它支持一系列的导航方法。比如查找与指定目标最匹配项。TreeSet 实现了Cloneable接口，意味着它能被克隆。
TreeSet 实现了java.io.Serializable接口，意味着它支持序列化。

2.TreeSet是基于TreeMap实现的。TreeSet中的元素支持2种排序方式：自然排序 或者 根据创建TreeSet 时提供的 Comparator 进行排序。这取决于使用的构造方法。

3.TreeSet为基本操作（add、remove 和 contains）提供受保证的 log(n) 时间开销。

4.TreeSet是非同步的。 它的iterator 方法返回的迭代器是fail-fast的。

Iterator和Enumeration区别

1.函数接口不同。Enumeration只有2个函数接口。通过Enumeration，我们只能读取集合的数据，而不能对数据进行修改。Iterator只有3个函数接口。Iterator除了能读取集合的数据之外，也能数据进行删除操作。

2.Iterator支持fail-fast机制，而Enumeration不支持。Enumeration 是JDK 1.0添加的接口。使用到它的函数包括Vector、Hashtable等类，这些类都是JDK 1.0中加入的，Enumeration存在的目的就是为它们提供遍历接口。Enumeration本身并没有支持同步，而在Vector、Hashtable实现Enumeration时，添加了同步。

3.Enumeration 比 Iterator 的遍历速度更快.