【Java8-集合源码学习2-ArrayList、Vector源码学习】
Collection
集合层次结构中的根接口。 一个集合表示一组对象，称为它的元素。一些集合允许重复元素，而另一些则不允许。有些是有序的，有些是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如Set和List ）的实现。他可以轻松的帮用户实现数据存储，动态扩容，还有方便的元素遍历和快速的增删改查等操作。Collection的子接口主要是三大类分别是List，Set和Queue。这三个接口各有特点。
Collection接口所有方法：
Collection三大子接口以及常用实现类：
-
List：List集合是有序集合，集合中的元素是可重复的，允许有多个null元素。访问元素可以根据元素的索引来访问。
- ArrayList：基于动态数组实现，支持随机访问。
- Vector：和 ArrayList 类似，但它是线程安全的。
- LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。
-
Set：Set集合是无序集合，集合中的元素不可重复，访问集合中的元素只能根据元素本身来访问。
- TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
- HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
- LinkedHashSet：具有 HashSet 的查找效率，并且内部使用双向链表维护元素的插入顺序。
-
Queue：顾名思义就是队列，队列最大的特点就是FIFO先进先出，与之对应的有栈Stack后进先出。Queue在Collection的基础之上又新增加了如下几个方法：（详细用法看jdk源码或者api文档）
- LinkedList：可以用它来实现双向队列。
- PriorityQueue：基于堆结构实现，可以用它来实现优先队列。
Map
和Collection一样，Map也是集合容器的一个顶层接口。Map是通过key-value方式存储数据，key值都是唯一的，但key是否能为空，则要看他的不同子类的实现。我们可以把Map看成一个小型的数字字典，通过key值的方式存储数据性能非常快，比如他的子类HashMap，底层就是通过散列表来实现存储，他的时间复杂度是O(1)。另一个典型的子类TreeMap是基于红黑树实现的，时间复杂度为O(log n)。
| method | desc |
|---|---|
| size() | 获取容器中元素的个数 |
| isEmpty() | 判断容器中是否包含元素，如果不包含元素，返回true |
| containsKey(Object key) | 判断是否包含key值 |
| containsValue(Object value) | 判断是否包含value |
| get(Object key) | 通过key值获取元素 |
| put(K key, V value) | 将一个元素通过键值对的方式存入容器，如果以存在这个key，则会替换value。 |
| remove(Object key) | 移除一个元素 |
| putAll(Map m) | 将容器中所有元素拷贝到当前容器。 |
| clear() | 清空容器中所有键值对 |
| interface Entry | 这个内部接口其实也是一个顶层接口，所有存入容器的元素首先都会被包装成一个entry元素。Map的不同子类都会实现这个接口，而且实现各不相同。原因很简单，每个子类都有独特的数据结构来存储数据，TreeMap用的是红黑树，HashMap用的是散列表，而LinkedHashMap则是用散列表+双向链表实现的。 |
其他方法见jdk1.8api文档。
下面是三个类对Entry的部分实现代码：
TreeMap：
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
Entry<K,V> left;
Entry<K,V> right;
Entry<K,V> parent;
boolean color = BLACK;
}
HashMap:
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
LinkedHashMap:
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
AbstractMap
AbstractMap这个类没特别的地方，他相当于一个骨架，对Map中的接口方法做了一个最简化的实现，设计他的目的是为了最小化接口实现的压力。
SortedMap
SortedMap是Map的子接口，他是一个排序接口，所有实现他的子类都是排序的，通常都是根据key进行排序。因此所有key值都必须实现Comparator接口。下面列举几个他特有的排序方法。
| method | desc |
|---|---|
| firstKey() | 获取集合中第一个键 |
| lastKey() | 获取集合中最后一个键 |
Map常见实现类：
- TreeMap：基于红黑树实现。
- HashMap：基于哈希表实现。
- Hashtable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程同时写入 Hashtable 不会导致数据不一致。它是遗留类，不应该去使用它，而是使用 ConcurrentHashMap 来支持线程安全，ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
- LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。
容器中的设计模式
1、迭代器模式
Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。
从 JDK 1.5 之后可以使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
for (String item : list) {
System.out.println(item);
}
2、适配器模式
java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
源码：
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
asList()参数是泛型的可变形参，不能使用基本类型数组作为参数，只能使用相应的包装类型数组，如下。
Integer[] arr = {1, 2, 3};
List list = Arrays.asList(arr);
也可以使用以下方式调用 asList()：
List list = Arrays.asList(1, 2, 3);
源码分析
ArrayList&Vector
之所以两者一块分析，主要还是两者源码相似度很高，Vector很少使用还是以ArrayList源码分析为主。
ArrayList
1、概述
因为 ArrayList 是基于数组（Object数组）实现的，所以支持快速随机访问。RandomAccess 接口标识着该类支持快速随机访问。
数组默认初始容量为10。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
// 数组默认初始容量10
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
// 真正的存储空间
transient Object[] elementData;
private int size;
}
2、动态扩容
添加操作才会涉及扩容，因此看添加源码：
public boolean add(E e) {
// 每次添加元素之前先动态调整数组大小，避免溢出
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
// 如果当前容器为空，那么就先初始化数组，数组大小默认为10
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 如果当前元素数量达到了容器的上限，那么就扩充数组
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// oldCapacity为当前容器大小
int oldCapacity = elementData.length;
// oldCapacity >> 1和oldCapacity / 2是等效的，因此newCapacity为原来的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 因为第一次容器有可能为空，elementData.length==0，newCapacity会小于minCapacity
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 当然newCapacity也不能大于MAX_ARRAY_SIZE，因为数组能分配的最大空间就是Integer.MAX_VALUE
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 当确定好数组大小后，就可以进行数组拷贝
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE)
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用grow()方法进行扩容，新容量的大小为 oldCapacity + (oldCapacity >> 1)，即 oldCapacity+oldCapacity/2。其中 oldCapacity >> 1 需要取整，所以新容量大约是旧容量的 1.5 倍左右。（oldCapacity 为偶数就是 1.5 倍，为奇数就是 1.5 倍-0.5）
扩容操作需要调用 Arrays.copyOf() 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
3、删除元素
需要调用 System.arraycopy() 将 index后面的所有元素都向前移动一位，该操作的时间复杂度为 O(N)，可以看到 ArrayList 删除元素的代价也是非常高的。
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
// 直接进行数组拷贝操作，把index后的所有元素向前移动一位
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 把最后的元素设空，等待垃圾回收
elementData[--size] = null;
return oldValue;
}
4、迭代器
在java集合类中，所有的集合都实现了Iterator接口，而List接口同时实现了ListIterator接口，这就决定了ArrayList他同时拥有两种迭代遍历的基因—Itr和ListItr。
4.1、Itr
Itr实现的是Iterator接口，拥有对元素向后遍历的能力
主要代码:
private class Itr implements Iterator<E> {
int cursor; // 下个元素的下标
int lastRet = -1; // 指向在遍历过程中，最后返回的那个元素。 如果没有为-1。
public boolean hasNext() {
return cursor != size;
}
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
// 遍历每一个元素下标都会往后移一位
cursor = i + 1;
// 返回当前元素，并把lastRet指向当前这个元素
return (E) elementData[lastRet = i];
}
// 调用此方法前，必须调用next方法，从lastRet可以看出，如果当前没有调用next，那么lastRet=-1，直接抛出异常
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
4.2、ListItr
ListItr不但继承了Itr类，也实现了ListIterator接口，因此他拥有双向遍历的能力。这里着重介绍一下向前遍历的原理。
public boolean hasPrevious() {
return cursor != 0;
}
public int previousIndex() {
// 通过cursor-1，将指针向前移位。
return cursor - 1;
}
// 返回前一个元素
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
5、Fail-Fast
modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
Vector
1、同步
它的实现与 ArrayList 类似，但是所有方法使用了 synchronized 进行同步，因此效率比较低，线程安全。
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
2、动态扩容
Vector 的构造函数可以传入 capacityIncrement 参数，它的作用是在扩容时使容量 capacity 增长 capacityIncrement。如果这个参数的值小于等于 0，扩容时每次都令 capacity 为原来的两倍。
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
扩容方法：
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// 三元表达式：capacityIncrement如果大于0，扩容capacityIncrement，否则扩容为原来的二倍
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
调用没有 capacityIncrement 的构造函数或者空参构造函数时，capacityIncrement 值默认被设置为 0，也就是说默认情况下 Vector 每次扩容时容量都会翻倍。
public Vector() {
this(10);
}
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
ArrayList与Vector异同点：
相同点：
- 都是List接口的直接实现类，都是基于数组实现的，都可以进行动态扩容。
不同点：
- Vector由于所有方法都是由synchronized修饰的，因此效率相比ArrayList较低，但是其线程安全。
- 两者默认初始容量都是10，但是动态扩容不太一样，ArrayList会扩容为原来的1.5倍，而Vector默认扩容为原来的2倍（也可以通过构造函数设置增长的容量）。
最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制。
替代方案：
可以使用 Collections.synchronizedList(); 得到一个线程安全的 ArrayList。
List<String> list = new ArrayList<>();
List<String> synList = Collections.synchronizedList(list);
也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
List<String> list = new CopyOnWriteArrayList<>();
ArrayList和Vector在多线程环境下对比
demo如下：
public class ArrayListAndVectorDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>(11);
Vector<String> vector = new Vector<>();
//使用ArrayList的时候，这里会报异常java.util.ConcurrentModificationException；Vector则不会
for (int i = 1; i < 30; i++) {
new Thread(() -> {
vector.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(vector);
}, "test" + i).start();
}
}
}
报错如下：
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
主要就是多线程下的并发操作，导致期望修改数与实际修改数不一致导致的问题。