java的集合是常用的类，也是面试官非常喜欢的问题。集合可以分为set集合、list集合和map集合list集合，这篇博客会分析list集合。时间非常紧迫的同学可以直接看最后的总结。
首先看一下List类的体系结构，JDK版本为1.8.0
List体系中有三个我们常用的类：ArrayList、Vector、LinkedList。
下面主意分析这三个类
ArrayList
ArrayList内部使用数组来保存对象，在数组长度不够的时候，增加数组的长度。
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable
ArrayList继承了AbstractList，实现了List、Random、Colleable、Serializable接口，ArrayList有一个泛型，用来指定保存的对象类型。
ArrayList的成员变量
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认的数组容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 默认空数组
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 默认空数组
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 用于保存数据的数组
* 不可序列化
*/
transient Object[] elementData; //
/**
* 当前保存的数据数量
*
* @serial
*/
private int size;
ArrayList的构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
无参构造方法中将elementData默认初始化为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，也就是一个空的数组。
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity]; //如果指定的初始容量initialCapacity大于0，就创建initialCapacity大小的数组
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA; //如果initialCapacity等于0，将elementData 初始化为空数组
} else {
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
}
一个参数int initialCapacity的构造方法中，根据传入的初始化容量，创建不同长度的数组。如果initialCapacity大于0，创建initialCapacity长度的数组；如果initialCapacity等于0，使elementData 指向一个长度为0的数组；如果initialCapacity长度小于0，抛出异常。
public ArrayList(Collection c) {
elementData = c.toArray(); //将传入的集合赋值给elementData
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
一个参数Collection c的构造方法，将传入的集合赋值给elementData，更新数组长度size。
？值得是泛型通配符，可以指代不同的泛型，具体可以看这一篇文章Java总结篇系列：Java泛型。
private void grow(int minCapacity)
grow方法是进行list中数组扩容的，传入当前需要的最小数组长度。下面看源码。
private void grow(int minCapacity) {
int oldCapacity = elementData.length; //获得数组现有的长度
int newCapacity = oldCapacity + (oldCapacity >> 1); //数组新长度是现有长度的1.5倍
if (newCapacity - minCapacity < 0) //如果新长度仍然不满足需求的长度
newCapacity = minCapacity; //就设置新长度为需求的长度
if (newCapacity - MAX_ARRAY_SIZE > 0) //如果长度超过所能承受的最大长度Integer.MAX_VALUE - 8
newCapacity = hugeCapacity(minCapacity); //使用hugeCapacity方法设置新长度
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity); //复制数组元素
}
上面程序中首先获得数组的现有长度，然后设置数组新长度是现有长度的1.5倍，如果新长度仍小于所需长度，则设置新长度等于所需长度。如果新长度大于最大长度，则使用hugeCapacity方法设置新长度。下面看hugeCapacity方法。
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow //如果长度超过整形的最大值，则抛出异常
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? //返回整形的最大长度
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
所以，ArrayList的最大长度是整型的最大值，超过这个值就会报OutOfMemoryError（）。
public boolean add(E e)
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 数据长度自增
elementData[size++] = e;
return true;
}
在add方法中，首先会使用ensureCapacityInternal(size + 1)方法进行数据数组扩容，然后将待插入的元素插入到数组末尾。
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //如果当前数据数组是空数组
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); //最小长度是10和所需长度的最大值
}
ensureExplicitCapacity(minCapacity); //数据数组扩容
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++; //操作数自增
if (minCapacity - elementData.length > 0)
grow(minCapacity); //数据数组扩容
}
add方法总结：
add方法中，首先会对数据数组进行扩容（如果现有的容量小于所需的容量，就扩容）。如果第一次添加数据，也就是数据数组是空数组的时候，设置最小的所需长度是10（我认为是为了避免数据数组在刚开始的时候长度增长地过慢，导致经常扩容，影响效率），然后使用grow方法对数据进行扩容（每次增长为原来的1.5倍）。
public boolean addAll(Collection c)
public boolean addAll(Collection c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
首先将输入的待插入集合转化为数组，然后对数据数组扩容，复制数组，更新size，返回。
public E set(int index, E element)
public E set(int index, E element) {
rangeCheck(index); //检查数组是否越界
E oldValue = elementData(index);
elementData[index] = element; //设置新数据
return oldValue; //返回旧数据
}
set方法中逻辑比较简单，首先判断数组是否越界，如果越界抛出IndexOutOfBoundsException异常，然后将新数据设置到指定位置，返回旧数据。
public E remove(int index)
public E remove(int index) {
rangeCheck(index); //检查数组是否越界
modCount++;
E oldValue = elementData(index); //取得需要删除的元素
int numMoved = size - index - 1; //获得需要移动的数据长度
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, //移动数据，填补空缺
numMoved);
elementData[--size] = null; // clear to let GC do its work //最后一个数据设置为null
return oldValue;
}
remove方法的逻辑同样简单，首先检查index是否越界（如果越界，抛出IndexOutOfBoundsException），然后获得需要删除的元素，删除中间的一个元素后，后面的元素都需要前移一位，原来最后位置的元素设置为null，最后返回移除的元素。
public E get(int index)
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
get方法逻辑比较简单，首先检查index是否越界，然后然后返回指定位置的数据
内部类private class Itr implements Iterator
ArrayList中有个内部类Itr，实现了Iterator接口，也就是我们常说的迭代器。
private class Itr implements Iterator {
int cursor; // 游标，指向下一个可以返回的数据
int lastRet = -1; // 游标，指向最后一个已返回的元素
int expectedModCount = modCount; //操作次数
public boolean hasNext() { //通过比较ArrayList中的成员变量size和迭代器的游标cursor，判断否是还有下一个元素
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification(); //如果迭代器中的操作数和ArrayList中的操作数不相等，就抛出异常。因此，我们在使用迭代器的时候，不应该使用ArrayList自身的add,remove,set等方法，否则迭代器会抛出异常！
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i]; //返回数据，游标后移，设置lastRet为刚刚返回的元素
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet); //移除上一个返回的元素
cursor = lastRet;
lastRet = -1; //重新设置lastRet为-1，所以next一次，只能remove一次。
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
迭代器总结：
1.迭代器封装了对集合元素的next和remove操作，不需要了解集合底层具体的实现，只需要使用迭代器进行统一处理
2.迭代器的remove操作是调用ArrayList的remove操作，迭代器本身不对ArrayList的结构产生变化。
2.迭代器内部会保存一个操作数，每次操作，迭代器都会检查自身的操作数和ArrayList的操作数是否相等，如果不相等会抛出异常。因此，我们在使用迭代器的时候再获取迭代器的对象，并且在使用迭代器的过程中，不应该使用ArrayList本身对数进行结构性的改变（add,remove等）。
Vector
public class Vector extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable
Vector和ArrayList的实现原理大致相同，都是在内部使用数组来保存数据，add和remove也都是先扩容，然后对数组进行操作。最大的不一样是Vector内部方法都用Synchronized修饰，也就是多线程同步的。并且数组扩容的方法也不太一样。
首先看构造方法
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
/**
*
*/
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
/**
*
*/
public Vector() {
this(10);
}
Vector有三个构造方法，分别是无参，一个参数（初始化容量），两个参数（初始化容量，每次扩容增长的容量）。前两个构造方法最后都是调用两个参数的构造方法。
可以看到，如果不设置默认的初始容量是10，默认每次扩容增加的容量是0。
private void grow(int minCapacity)
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ? //如果默认的扩容增量等于0，就设置新的容量为旧容量的两倍，否则根据容量增量增加容量。
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
grow方法中，会判断现在的扩容增量值是不是等于0，如果等于0，则新容量是旧容量的两倍，否则，根据扩容增量设置新的容量。
Vector总结：
1.基本原理和ArrayList相同，内部使用数组保存数据，在需要的时候扩容数组
2.构造方法方法中，可以设置初始的容量和每次扩容增加的容量。默认初始容量是10，每次扩容增加的容量是0。
3.对数据的结构性操作的函数都使用Synchronized来修饰（如add,remove,setSize），是线程安全的，但是多线程环境下效率比较低。
4.每次扩容，如果现有设置的扩容增量为0，则新容量为旧容量的两倍，否则，新容量为旧容量+扩容增量。
LinkedList
public class LinkedList
extends AbstractSequentialList
implements List, Deque, Cloneable, java.io.Serializable
ArrayList和Vector内部都是用数组来存储元素，LinkedList内部使用双向链表来存储数据（jdk1.8.0中不是循环链表）。下面的分析只对源码中的思路进行分析，不对具体的链表操作进行分析。
成员变量
transient int size = 0; //已存储元素的多少
/**
* 指向链表中第一个元素的指针
*/
transient Node first;
/**
* 指向链表中最后一个元素的指针
*/
transient Node last;
LinkedList中保存了指向第一个元素和最后一个元素的指针。
构造方法
public LinkedList() {
}
public LinkedList(Collection c) {
this();
addAll(c);
}
提供了两个构造方法，一个没有任何逻辑，一个传入数据集合，调用addAll插入数据集合。
boolean addAll(int index, Collection c)
public boolean addAll(int index, Collection c) {
checkPositionIndex(index); //检查是否越界
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index); //使用node（index）查找到指定位置的元素
pred = succ.prev;
}
for (Object o : a) { //将数据插入到链表中
@SuppressWarnings("unchecked") E e = (E) o;
Node newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) { //更新last指针
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew; //修改size
modCount++; //修改操作数
return true;
}
Node node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
在AddAll方法中首先使用node(int index)找到插入点，然后将数据插入到双向链表中
public boolean add(E e)
public boolean add(E e) {
linkLast(e);
return true;
}
调用linkLast将元素插入到链表尾部，具体怎么插入就不分析了，就是双向链表的插入操作。
public boolean remove(Object o)
public boolean remove(Object o) {
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
在remove（Object o）方法中，首先判断o是不是null，如果是，则通过for循环查到链表中第一个值为null的结点；否则，通过for循环找到指定结点，删除。
public E get(int index)
public E get(int index) {
checkElementIndex(index); //检查是否越界
return node(index).item; //使用node获取指定位置的结点
}
public E peek()
public E peek() {
final Node f = first;
return (f == null) ? null : f.item;
}
返回链表中的第一个元素
public E poll()
public E poll() {
final Node f = first;
return (f == null) ? null : unlinkFirst(f);
}
首先获取链表中第一个元素，断开其连接，返回该元素。
public boolean offer(E e)
public boolean offer(E e) {
return add(e);
}
offer方法中调用add方法将元素插入到链表末尾，
public void push(E e)
public void push(E e) {
addFirst(e);
}
使用addFirst(e)将数据插入到链表开头
public E pop()
public E pop() {
return removeFirst();
}
使用removeFirst返回链表的头结点，断开头结点与其他结点的连接
public void clear()
public void clear() {
for (Node x = first; x != null; ) { //将结点的引用指向null，使实例对象可以被GC
Node next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null; //重置头节点和尾结点
size = 0; //设置size为0
modCount++;
}
LinkedList总结
1.使用双向链表来保存数据，数据插入，删除都是通过对链表操作来实现的。
2.继承了queue接口，可以当作队列来使用。也提供了栈的方法，也可以当作栈使用。