前言
上一篇文章探究了Collection接口的详细设计和相关的方法。文章的链接如下：
http://blog.csdn.net/kiritor/article/details/8869937，接下来将会探究其子接口List的源码，通过
源码探究其接口设计和特点。
List接口设计
通过查阅源码，我们知道的是List接口继承至Collection接口，并且实现了集合中元素的有序存
储。也就是说用户可以对列表中的每个元素的插入位置进行精确的控制，可以根据元素在集合中
的索引对元素进行访问和遍历(类似数组)。
List接口源代码解析
对于List接口的设计，我们直接看源码和API来的更加实际一些。
package com.kiritor;
import java.util.Iterator;
import java.util.ListIterator;
/**
* List源码探究
* @author Kiritor*/
public interface List<E> extends Collection<E> {
/**List作为Collection的子接口
* 提供了Collection接口定义的方法
* 这些方法在Collection源码学习中
* 已经分析过了，就不在说明了
* */
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean addAll(int index, Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
void clear();
boolean equals(Object o);
int hashCode();
/**同时List接口定义了一些自己的方法
* 来实现“有序”这一功能特点*/
/**
*返回列表中指定索引的元素
*return E
*throws IndexOutofBoundException(index<0||index>=size())
* */
E get(int index);
/**
*设定某个列表索引的值
*throws：
*UnsupportedOperationException
ClassCastException
NullPointerException
IllegalArgumentException
IndexOutOfBoundsException
* */
E set(int index, E element);
/**
*在指定位置插入元素，当前元素和后续元素后移
*这是可选操作，类似于顺序表的插入操作 */
void add(int index, E element);
/**
* 删除指定位置的元素(可选操作)*/
E remove(int index);
/**
* 获得指定对象的最小索引位置，
* 没有则返回-1*/
int indexOf(Object o);
/**获得指定对象的最大索引位置
* 可以知道的是若集合中无给定元素的重复元素下
* 其和indexOf返回值是一样的*/
int lastIndexOf(Object o);
/**一种更加强大的迭代器，支持向前遍历，向后遍历
* 插入删除操作，此处不解释*/
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
/**
* 返回索引fromIndex(包括)和toIndex(不包括)
* 之间的视图。*/
List<E> subList(int fromIndex, int toIndex);
}
ArrayList类实现
对于ArrayList类的实现笔者就不将代码一一贴出来了，这里只是简要的对一些个方法的
实现做一些分析。首先我们看看ArrayList类头吧
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.SerializableRandomAccess：List实现使用的标记接口，主要用于提高连续或随机访问列表时的性能。
Cloneable：实现该接口的类可以对该类的实例进行克隆（按字段进行复制）
Serializable：用于标识可序列化（何为序列化？为什么要序列化，有待总结）
1、底层实现
通过对其源码的观察，可以发现的是ArrayList的底层是通过数组来实现的。
private transient Object[] elementData;
private int size;
Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的
对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭
serialization，可以在这个域前加上关键字transient。
2、构造方法
通过查看源码，我们可以知道的是ArrayList提供三种构造方法
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
public ArrayList() {
this(10);
}
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}第三种构造则显得稍微复杂些，它是将给定集合转换成数组(按照集合本身的顺序)，如果
转化成的emlementData不是Object[]类型则调用Arrays.copyOf方法将其转换为Object[]。
Tips：需要特别注意前两个构造方法和第三个构造方法的区别，前两者生成的集合是
无元素的，代码中也没有对size进行修改的地方，第三个构造器对size是有修改的。
3、存储元素
ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、
addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)这些添加
元素的方法。下面我们一一讲解：
/*
* 用指定的元素代替集合中指定位置的元素
* 并返回以前位于该位置的
*/
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
set方法会通过rangeCheck()函数检查index的返回，若index>=size则会主动抛出
IndexOutOfBoundsException异常，不过需要注意的是对于index<0的情况并不会主动抛出
该异常，且两种情况抛出的异常详细信息不同(如何不同读者可自己尝试)，这对于我们以后
ArrayList下表越界错误的查找也算有一定的帮助吧，助于说为什么JDK对于该方法为什么
不将index<0情况考虑进去，可能是因为对于数组越界的问题，我们更加关心的是“向前越界”
// 将指定的元素添加到此列表的尾部。
public boolean add(E e) {
ensureCapacity(size + 1); //该方法用于调整数组的容量
elementData[size++] = e;
return true;
} 会详细分析。
// 将指定的元素插入此列表中的指定位置。
// 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引加1）。
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
// 如果数组长度不足，将进行扩容。
ensureCapacity(size+1); // Increments modCount!!
// 将 elementData中从Index位置开始、长度为size-index的元素，
// 拷贝到从下标为index+1位置开始的新的elementData数组中。
// 即将当前位于该位置的元素以及所有后续元素右移一个位置。
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = element;
size++;
} // 按照指定collection的迭代器所返回的元素顺序，将该collection中的所有元素添加到此列表的尾部。
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
} // 从指定的位置开始，将指定collection中的所有元素插入到此列表中。
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
} 4、读取元素
//返回列表中指定位置的元素，需边界检查
public E get(int index) {
rangeCheck(index);
return elementData(index);
}5、删除元素
ArrayList提供了根据下标或者指定对象两种方式来删除元素代码如下： // 移除此列表中指定位置上的元素,并返回，需边界转换
public E remove(int index) {
RangeCheck(index);
modCount++;
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--size] = null; // Let gc do its work
return oldValue;
} // 移除此列表中首次出现的指定元素（如果存在）。这是应为ArrayList中允许存放重复的元素。
//该方法通过对象删除，不许进行边界检查
public boolean remove(Object o) {
// 由于ArrayList中允许存放null，因此下面通过两种情况来分别处理。
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
// 类似remove(int index)，移除列表中指定位置上的元素。
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
} 类似，但是并不需要进行边界检查（通过remove(Object o)已经可以index的合理性了），容易
明白的是该方法不应该直接调用，因此设定为private的，对象引用无法直接调用它，安全性得以
保障。
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
}6、调整容量
很久以前我们就知道ArrayList等集合都是动态的，那么这种动态是如何来实现的？通过 查阅源码，这种动态性的实现主要有下面两个方法实现的。
public void ensureCapacity(int minCapacity) {
if (minCapacity > 0)
ensureCapacityInternal(minCapacity);
}
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
其工作过程以add方法为例
// 将指定的元素添加到此列表的尾部。
public boolean add(E e) {
ensureCapacity(size + 1); //该方法用于调整数组的容量
elementData[size++] = e;
return true;
}
在进行元素尾部插入的时候，首先确保插入元素后集合的size也就是minCapacity必须<=
集合的容量，也就是elementData.lentgh，如果大于集合的容量之后则需通过grow方法
进行扩容。阅读下面方法很容易知道ArrayList是按照自己的50%扩容的。
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}代价是挺高的，因此我们应该尽量避免数组的扩容。而且需注意一点的是ensureCapacity()方法
是public的，我们可以通过它手动的增加容量。
而且ArrayList提供了一个有趣的方法，它可以将底层数组的容量调整为集合中实际元素的数量
public void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (size < oldCapacity) {
elementData = Arrays.copyOf(elementData, size);
}
} 7、Fail-Fast(快速失败)机制
仔细观察上述的各个方法，我们在源码中就会发现一个特别的属性modCount，API解释如下：
The number of times this list has been structurally modified. Structural modifications are those
that change the size of the list, or otherwise perturb it in such a fashion that iterations in progress
may yield incorrect results.
记录修改此列表的次数：包括改变列表的结构，改变列表的大小，打乱列表的顺序等使正在进行
迭代产生错误的结果。Tips:仅仅设置元素的值并不是结构的修改
我们知道的是ArrayList是线程不安全的，如果在使用迭代器的过程中有其他的线程修改了List就会
抛出ConcurrentModificationException这就是Fail-Fast机制。
那么快速失败究竟是个什么意思呢？
在ArrayList类创建迭代器之后，除非通过迭代器自身remove或add对列表结构进行修改，否则在其他
线程中以任何形式对列表进行修改，迭代器马上会抛出异常，快速失败。
8、迭代器遍历
我们知道Collection接口都有产生迭代器的接口，作为List接口的具体实现类ArrayList来说肯定是
少不了的，而且ArrayList同时还提供一个ListIterator实现更为灵活的遍历，这里我们就Iterator做一些
探究吧。看看产生Iterator的方法
/*返回一个迭代器接口的具体实现类*/
public Iterator<E> iterator() {
return new Itr();
}
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
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;
return (E) elementData[lastRet = i];
}
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();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
生成一个迭代器对象，通过迭代器对象提供的方法，实现集合的遍历等操作。
留意到的是checkForComodification可以知道，当多个线程同时操作一个ArrayList造成
modeCount不一致时，会抛出ConcurrentModificationException异常，仔细观察又可以发现的是
迭代器每一个方法执行都需要调用checkForComodification()方法，这样就实现了上面所说的
Fail-Fast（快速失败），相较于迭代完成之后抛出异常更合理些。
9、一个小"陷阱"
通过阅读源码笔者还发现了一个有意思的问题，那就是subList(index1,index2)方法,返回一个
从index1(包括)开始到index2（不包括）的子列表。通过观察可发现的是这里子列表的幕后还是原
列表，对其的修改也会造成原列表的修改。
如果不想出现这种情况，很简单 new ArrayList(list.subList(index1,index2));就ok了。
好了，对于List、ArrayList的整理就到这个地方了，对于一些细节的东西笔者难免有些遗漏的
地方，希望给予指出与交流！
1851
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
