目录
一、Java 集合介绍
二、List
2.1 ArrayList
2.2 LinkedList
2.3 Vector
2.4 Stack
2.5 CopyOnWriteArrayList
2.6 CopyOnWriteArraySet
2.7 ArrayList 和 Vector 区别
2.8 ArrayList 与 LinkedList 的区别
一、Java 集合介绍
Java 集合是一个存储相同类型数据的容器，类似数组，集合可以不指定长度，但是数组必须指定长度。集合类主要从 Collection 和 Map 两个根接口派生出来，比如常用的 ArrayList、LinkedList、HashMap、HashSet、ConcurrentHashMap 等等。
二、List
2.1 ArrayList
ArrayList 是基于动态数组实现，容量能自动增长的集合。随机访问效率高，随机插入、随机删除效率低。线程不安全，多线程环境下可以使用 Collections.synchronizedList(list) 函数返回一个线程安全的 ArrayList 类，也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
2.1.1先说说synchronizedList(list) 底层源码如下：
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;
final List<E> list;
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
SynchronizedList(List<E> list, Object mutex) {
super(list, mutex);
this.list = list;
}
public boolean equals(Object o) {
if (this == o)
return true;
synchronized (mutex) {return list.equals(o);}
}
public int hashCode() {
synchronized (mutex) {return list.hashCode();}
}
public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}
public int indexOf(Object o) {
synchronized (mutex) {return list.indexOf(o);}
}
public int lastIndexOf(Object o) {
synchronized (mutex) {return list.lastIndexOf(o);}
}
public boolean addAll(int index, Collection<? extends E> c) {
synchronized (mutex) {return list.addAll(index, c);}
}
public ListIterator<E> listIterator() {
return list.listIterator(); // Must be manually synched by user
}
public ListIterator<E> listIterator(int index) {
return list.listIterator(index); // Must be manually synched by user
}
public List<E> subList(int fromIndex, int toIndex) {
synchronized (mutex) {
return new SynchronizedList<>(list.subList(fromIndex, toIndex),
mutex);
}
}
@Override
public void replaceAll(UnaryOperator<E> operator) {
synchronized (mutex) {list.replaceAll(operator);}
}
@Override
public void sort(Comparator<? super E> c) {
synchronized (mutex) {list.sort(c);}
}
private Object readResolve() {
return (list instanceof RandomAccess
? new SynchronizedRandomAccessList<>(list)
: this);
}
}
使用方式如下，官方文档就是下面的使用方式
List list = Collections.synchronizedList(new ArrayList());
...
synchronized (list) {
Iterator i = list.iterator(); // Must be in synchronized block
while (i.hasNext())
foo(i.next());
}
既然封装类内部已经加了对象锁，为什么外部还要加一层对象锁？
看源码可知，Collections.synchronizedList中很多方法，比如equals,hasCode,get,set,add,remove,indexOf,lastIndexOf......
都添加了锁，但是List中
Iterator<E> iterator();这个方法没有加锁，不是线程安全的，所以如果要遍历，还是必须要在外面加一层锁。
使用Iterator迭代器的话，似乎也没必要用Collections.synchronizedList的方法来包装了——反正都是必须要使用Synchronized代码块包起来的。
所以总的来说，Collections.synchronizedList这种做法，适合不需要使用Iterator、对性能要求也不高的情况。SynchronizedList和Vector最主要的区别：
- Vector扩容为原来的2倍长度，ArrayList扩容为原来1.5倍
- SynchronizedList有很好的扩展和兼容功能。他可以将所有的List的子类转成线程安全的类。
- 使用SynchronizedList的时候，进行遍历时要手动进行同步处理 。
- SynchronizedList可以指定锁定的对象。
2.1.2再说说CopyOnWriteArrayList,同样我们进源码了解：
CopyOnWriteArrayList是Java并发包中提供的一个并发容器，它是个线程安全且读操作无锁的ArrayList，写操作则通过创建底层数组的新副本来实现，是一种读写分离的并发策略，我们也可以称这种容器为"写时复制器"，Java并发包中类似的容器还有CopyOnWriteSet。
我们都知道，集合框架中的ArrayList是非线程安全的，Vector虽是线程安全的，但由于简单粗暴的锁同步机制，性能较差。而CopyOnWriteArrayList则提供了另一种不同的并发处理策略（当然是针对特定的并发场景）。
很多时候，我们的系统应对的都是读多写少的并发场景。CopyOnWriteArrayList容器允许并发读，读操作是无锁的，性能较高。至于写操作，比如向容器中添加一个元素，则首先将当前容器复制一份，然后在新副本上执行写操作，结束之后再将原容器的引用指向新容器。
优缺点分析
了解了CopyOnWriteArrayList的实现原理，分析它的优缺点及使用场景就很容易了。
优点：
读操作性能很高，因为无需任何同步措施，比较适用于读多写少的并发场景。Java的list在遍历时，若中途有别的线程对list容器进行修改，则会抛出ConcurrentModificationException异常。而CopyOnWriteArrayList由于其"读写分离"的思想，遍历和修改操作分别作用在不同的list容器，所以在使用迭代器进行遍历时候，也就不会抛出ConcurrentModificationException异常了
缺点：
缺点也很明显，一是内存占用问题，毕竟每次执行写操作都要将原容器拷贝一份，数据量大时，对内存压力较大，可能会引起频繁GC；二是无法保证实时性，Vector对于读写操作均加锁同步，可以保证读和写的强一致性。而CopyOnWriteArrayList由于其实现策略的原因，写和读分别作用在新老不同容器上，在写操作执行过程中，读不会阻塞但读取到的却是老容器的数据。
源码分析
基本原理了解了，CopyOnWriteArrayList的代码实现看起来就很容易理解了。
添加操作：
public boolean add(E e) {
//ReentrantLock加锁，保证线程安全
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
//拷贝原容器，长度为原容器长度加一
Object[] newElements = Arrays.copyOf(elements, len + 1);
//在新副本上执行添加操作
newElements[len] = e;
//将原容器引用指向新副本
setArray(newElements);
return true;
} finally {
//解锁
lock.unlock();
}
}
添加的逻辑很简单，先将原容器copy一份，然后在新副本上执行写操作，之后再切换引用。当然此过程是要加锁的。
删除操作
public E remove(int index) {
//加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
E oldValue = get(elements, index);
int numMoved = len - index - 1;
if (numMoved == 0)
//如果要删除的是列表末端数据，拷贝前len-1个数据到新副本上，再切换引用
setArray(Arrays.copyOf(elements, len - 1));
else {
//否则，将除要删除元素之外的其他元素拷贝到新副本中，并切换引用
Object[] newElements = new Object[len - 1];
System.arraycopy(elements, 0, newElements, 0, index);
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
setArray(newElements);
}
return oldValue;
} finally {
//解锁
lock.unlock();
}
}
删除操作同理，将除要删除元素之外的其他元素拷贝到新副本中，然后切换引用，将原容器引用指向新副本。同属写操作，需要加锁。
我们再来看看读操作，CopyOnWriteArrayList的读操作是不用加锁的，性能很高。
public E get(int index) {
return get(getArray(), index);
}直接读取即可，无需加锁
动态数组，是指当数组容量不足以存放新的元素时，会创建新的数组，然后把原数组中的内容复制到新数组。
主要属性：
//存储实际数据，使用transient修饰，序列化的时不会被保存
transient Object[] elementData;
//元素的数量，即容量。
private int size;特征：
- 允许元素为 null；
- 查询效率高、插入、删除效率低，因为大量 copy 原来元素；
- 线程不安全。
使用场景：
- 需要快速随机访问元素
- 单线程环境
add(element) 流程：
- 判断当前数组是否为空，如果是则创建长度为 10（默认）的数组，因为 new ArrayList 的时是没有初始化；
- 判断是否需要扩容，如果当前数组的长度加 1（即 size+1）后是否大于当前数组长度，则进行扩容 grow()；
- 最后在数组末尾添加元素，并 size+1。
grow() 流程：
- 创建新数组，长度扩大为原数组的 1.5 倍；
- 如果扩大 1.5 倍还是不够，则根据实际长度来扩容，比如 addAll() 场景；
- 将原数组的数据使用 System.arraycopy（native 方法）复制到新数组中。
add(index,element) 流程：
1.检查 index 是否在数组范围内，假如数组长度是 2，则 index 必须 >=0 并且 <=2，否则报 IndexOutOfBoundsException 异常；
2.扩容检查；
3.通过拷贝方式，把数组位置为 index 至 size-1 的元素都往后移动一位，腾出位置之后放入元素，并 size+1。
set(index,element) 流程：
1.检查 index 是否在数组范围内，假如数组长度是 2，则 index 必须 >=0 并且 <2；
2.保留被覆盖的值，因为最后需要返回旧的值；
3.新元素覆盖位置为 index 的旧元素，返回旧值。
get(index) 流程：
1.判断下标有没有越界；
2.通过数组下标来获取元素，get 的时间复杂度是 O(1)。
remove(index) 流程：
1.检查指定位置是否在数组范围内，假如数组长度是 2，则 index 必须 >=0 并且 < 2；
2.保留要删除的值，因为最后需要返回旧的值；
3.计算出需要移动元素个数，再通过拷贝使数组内位置为 index+1 到 size-1 的元素往前移动一位，把数组最后一个元素设置为 null（精辟小技巧），返回旧值。
注意事项：
1.new ArrayList 创建对象时，如果没有指定集合容量则初始化为 0；如果有指定，则按照指定的大小初始化；
2.扩容时，先将集合扩大 1.5 倍，如果还是不够，则根据实际长度来扩容，保证都能存储所有数据，比如 addAll() 场景。
3.如果新扩容后数组长度大于（Integer.MAX_VALUE-8），则抛出 OutOfMemoryError。
2.2 LinkedList
LinkedList 是可以在任何位置进行插入和移除操作的有序集合，它是基于双向链表实现的，线程不安全。LinkedList 功能比较强大，可以实现栈、队列或双向队列。
主要属性：
//链表长度
transient int size = 0;
//头部节点
transient Node<E> first;
//尾部节点
transient Node<E> last;
/\*\* \* 静态内部类，存储数据的节点 \*/
private static class Node\<E\> {
//自身结点
E item;
//下一个节点
Node<E> next;
//上一个节点
Node<E> prev;
}
特征：
允许元素为 null；
插入和删除效率高，查询效率低；
顺序访问会非常高效，而随机访问效率（比如 get 方法）比较低；
既能实现栈 Stack（后进先出），也能实现队列（先进先出）, 也能实现双向队列，因为提供了 xxxFirst()、xxxLast() 等方法；
线程不安全。
使用场景：
需要快速插入，删除元素
按照顺序访问其中的元素
单线程环境
add() 流程：
创建一个新结点，结点元素 item 为传入参数，前继节点 prev 为“当前链表 last 结点”，后继节点 next 为 null；
判断当前链表 last 结点是否为空，如果是则把新建结点作为头结点，如果不是则把新结点作为 last 结点。
最后返回 true。
get(index,element) 流程：
检查 index 是否在数组范围内，假如数组长度是 2，则 index 必须 >=0 并且 < 2；
index 小于“双向链表长度的 1/2”则从头开始往后遍历查找，否则从链表末尾开始向前遍历查找。
remove() 流程：
判断 first 结点是否为空，如果是则报 NoSuchElementException 异常；
如果不为空，则把待删除结点的 next 结点的 prev 属性赋值为 null，达到删除头结点的效果。
返回删除值。
2.3 Vector
Vector 是矢量队列，也是基于动态数组实现，容量可以自动扩容。跟 ArrayList 实现原理一样，但是 Vector 是线程安全，使用 Synchronized 实现线程安全，性能非常差，已被淘汰，使用 CopyOnWriteArrayList 替代 Vector。
主要属性：
//存储实际数据
protected Object[] elementData;
//动态数组的实际大小
protected int elementCount;
//动态数组的扩容系数
protected int capacityIncrement;
特征：
允许元素为 null；
查询效率高、插入、删除效率低，因为需要移动元素；
默认的初始化大小为 10，没有指定增长系数则每次都是扩容一倍，如果扩容后还不够，则直接根据参数长度来扩容；
线程安全，性能差（Synchronized），使用 CopyOnWriteArrayList 替代 Vector。
**使用场景：**多线程环境
2.4 Stack
Stack 是栈，先进后出原则，Stack 继承 Vector，也是通过数组实现，线程安全。因为效率比较低，不推荐使用，可以使用 LinkedList（线程不安全）或者 ConcurrentLinkedDeque（线程安全）来实现先进先出的效果。
**数据结构：**动态数组
**构造函数：**只有一个默认 Stack()
**特征：**先进后出
实现原理：
Stack 执行 push() 时，将数据推进栈，即把数据追加到数组的末尾。
Stack 执行 peek 时，取出栈顶数据，不删除此数据，即获取数组首个元素。
Stack 执行 pop 时，取出栈顶数据，在栈顶删除数据，即删除数组首个元素。
Stack 继承于 Vector，所以 Vector 拥有的属性和功能，Stack 都拥有，比如 add()、set() 等等。
2.5 CopyOnWriteArrayList
CopyOnWriteArrayList 是线程安全的 ArrayList，写操作（add、set、remove 等等）时，把原数组拷贝一份出来，然后在新数组进行写操作，操作完后，再将原数组引用指向到新数组。CopyOnWriteArrayList 可以替代 Collections.synchronizedList(List list)。
**数据结构：**动态数组
特征：
线程安全；
读多写少，比如缓存；
不能保证实时一致性，只能保证最终一致性。
缺点：
写操作，需要拷贝数组，比较消耗内存，如果原数组容量大的情况下，可能触发频繁的 Young GC 或者 Full GC；
不能用于实时读的场景，因为读取到数据可能是旧的，可以保证最终一致性。
实现原理：
CopyOnWriteArrayList 写操作加了锁，不然多线程进行写操作时会复制多个副本；读操作没有加锁，所以可以实现并发读，但是可能读到旧的数据，比如正在执行读操作时，同时有多个写操作在进行，遇到这种场景时，就会都到旧数据。
2.6 CopyOnWriteArraySet
CopyOnWriteArraySet 是线程安全的无序并且不能重复的集合，可以认为是线程安全的 HashSet，底层是通过 CopyOnWriteArrayList 机制实现。
**数据结构：**动态数组（CopyOnWriteArrayList），并不是散列表。
特征：
线程安全
读多写少，比如缓存
不能存储重复元素
2.7 ArrayList 和 Vector 区别
Vector 线程安全，ArrayList 线程不安全；
ArrayList 在扩容时默认是扩展 1.5 倍，Vector 是默认扩展 1 倍；
ArrayList 支持序列化，Vector 不支持；
Vector 提供 indexOf(obj, start) 接口，ArrayList 没有；
Vector 构造函数可以指定扩容增加系数，ArrayList 不可以。
2.8 ArrayList 与 LinkedList 的区别
ArrayList 的数据结构是动态数组，LinkedList 的数据结构是链表；
ArrayList 不支持高效的插入和删除元素，LinkedList 不支持高效的随机访问元素；
ArrayList 的空间浪费在数组末尾预留一定的容量空间，LinkedList 的空间浪费在每一个结点都要消耗空间来存储 prev、next 等信息。
