前言
AbstractList是实现List接口的抽象类，AbstractList抽象类与List接口的关系类似于AbstractCollection抽象类与Collection接口的关系。AbstractList与AbstractCollection一样，也是通过提供一些方法的默认实现，简化我们编写List接口的列表类所需付出的努力。
实现列表类的需要记住：
一、类定义
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
除了实现List接口，AbstractList还继承了AbstractCollection抽象类。
二、方法定义
（一）构造方法
protected AbstractList() {
}
提供一个空构造方法，给子类的构造方法调用（通常是隐式调用）
（二）元素的增删改查
（1）
public boolean add(E e) {
add(size(), e);
return true;
}
添加指定元素到列表末端。此方法有可能抛出IndexOutOfBoundsException异常。
方法内部是通过调用add(int, E)方法实现的。
（2）
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
添加指定元素到列表的指定位置处。
方法内部默认抛出UnsupportedOperationException。正如前言所讲，如果我们要实现一个不可修改的列表类，则当调用添加方法时，则抛出不支持添加操作的异常；如果我们要实现一个可以修改的列表类，则必须重写此方法。重写此方法之后，此方法在调用过程中有可能抛出ClassCastException、NullPointerException、IllegalArgumentException、IndexOutOfBoundsException等异常。
（3）
public E remove(int index) {
throw new UnsupportedOperationException();
}
删除列表中指定位置的元素。
方法内部默认抛出UnsupportedOperationException。原因同上。
（4）
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
用指定元素更新列表中指定位置处的元素
方法内部默认抛出UnsupportedOperationException。同上面一样，如果我们要实现一个不可修改的列表类，那么无需实现此方法；反之，要重写此方法。重写此方法之后，此方法还可能抛出ClassCastException、NullPointerException、IllegalArgumentException、IndexOutOfBoundsException等异常。
（5）
abstract public E get(int index);
查找列表指定位置处的元素。此方法有可能抛出IndexOutOfBoundsException异常。
（6）
public int indexOf(Object o) {
ListIterator<E> it = listIterator();
if (o==null) {
while (it.hasNext())
if (it.next()==null)
return it.previousIndex();
} else {
while (it.hasNext())
if (o.equals(it.next()))
return it.previousIndex();
}
return -1;
}
查找指定元素在列表中第一次出现的索引。
通过列表迭代器的迭代实现。
（7）
public int lastIndexOf(Object o) {
ListIterator<E> it = listIterator(size());
if (o==null) {
while (it.hasPrevious())
if (it.previous()==null)
return it.nextIndex();
} else {
while (it.hasPrevious())
if (o.equals(it.previous()))
return it.nextIndex();
}
return -1;
}
查找指定元素在列表中最后一次出现的索引。
通过列表迭代器迭代实现。
（三）批量操作
（1）
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
boolean modified = false;
for (E e : c) {
add(index++, e);
modified = true;
}
return modified;
}
添加指定集合的所有元素到列表中。
首先通过rangeCheckForAdd()方法判断插入位置是否合法，合法则添加元素；否则抛出异常。
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size())
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
当index超出范围，rangeCheckForAdd()方法抛出IndexOutOfBoundsException异常。
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size();
}
抛出异常时，使用outOfBoundsMsg()方法提示异常具体信息。
（2）
public void clear() {
removeRange(0, size());
}
清空列表，即，删除列表所有元素
内部是通过removeRange()方法实现的
protected void removeRange(int fromIndex, int toIndex) {
ListIterator<E> it = listIterator(fromIndex);
for (int i=0, n=toIndex-fromIndex; i<n; i++) {
it.next();
it.remove();
}
}
（四）相等与哈希
（1）
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof List))
return false;
ListIterator<E> e1 = listIterator();
ListIterator<?> e2 = ((List<?>) o).listIterator();
while (e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
判断列表与指定对象是否相等，这里判断的是值相等，而不是同一个对象。
判等逻辑如下：
1）如果两个引用指向的对象是同一个对象，那么值肯定相等，返回true；否则，继续判断
2）如果指定对象不是列表，如指定对象是set集合，那么返回false；否则，继续判断
3）获取列表、指定对象的列表迭代器，遍历每个元素，并判断相同位置的元素值是否相等，如果有一个不等，则返回false；否则，说明其中一个迭代器的所有元素在另一个迭代器中出现，且出现的位置相同，如果此时不存在其中一个迭代器剩下元素，那直接返回true
（2）
public int hashCode() {
int hashCode = 1;
for (E e : this)
hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
return hashCode;
}
得到列表的哈希码值
方法内部实现是通过遍历列表的每一个元素，得到每个元素的哈希码值（若元素为null，则哈希码值为0；若不为null，则通过hashCode()方法获取元素的哈希码值），然后按照hashCode = 31*hashCode + (e==null ? 0 : e.hashCode()); 的规则计算列表的哈希码值，其中初始hashCode=1。当所有元素遍历完毕，最终的hashCode即为列表的哈希码值，返回即可。
（五）迭代器相关
（1）
public Iterator<E> iterator() {
return new Itr();
}
（2）
public ListIterator<E> listIterator() {
return listIterator(0);
}
（3）
public ListIterator<E> listIterator(final int index) {
rangeCheckForAdd(index);
return new ListItr(index);
}