标题：AbstractList
类型简介
java.util 
类 AbstractList<E>
java.lang.Object  java.util.AbstractCollection<E>
java.util.AbstractList<E>
所有已实现的接口：
Iterable<E>,Collection<E>,List<E> 
直接已知子类：
AbstractSequentialList,ArrayList,Vector 
--------------------------------------------------------------------------------
public abstract class AbstractList<E>extends
注意事项
AbstractList<E> extends AbstractCollection<E> implements List<E> 此类提供 List 接口的骨干实现，从而最大限度地减少了实现由“随机访问”数据存储（如数组）支持的接口所需的工作。对于连续的访问数据（如链表），应优先使用 AbstractSequentialList，而非此类。
要实现不可修改的列表，程序员只需扩展此类，并提供 get(int index) 和 size() 方法的实现。
要实现可修改的列表，程序员还必须另外重写 set(int index,Object element) 方法，否则将抛出 UnsupportedOperationException。如果列表为可变大小，则程序员必须另外重写 add(int index,Object element) 和 remove(int index) 方法。
按照 Collection 接口规范中的推荐，程序员通常应该提供一个 void （无参数）和 collection 构造方法。
与其他抽象 collection 实现不同，程序员不必 提供迭代器实现；迭代器和列表迭代器由此类在以下“随机访问”方法之上实现：get(int index）、set(int index,Object element）、set(int index,Object element）、add(int index,Object element) 和 remove(int index）。
此类中每个非抽象方法的文档详细描述了其实现。如果要实现的 collection 允许更有效的实现，则可以重写这些方法中的每个方法。
此类是 Java Collections Framework 的成员。
从以下版本开始：
⒈2 
另请参见：
Collection,List,AbstractSequentialList,AbstractCollection
--------------------------------------------------------------------------------
字段摘要 
protectedint modCount 
已从结构上修改 此列表的次数。
构造方法摘要 
protectedAbstractList() 
单独的构造方法。
方法摘要
boolean add(E o) 
将指定的元素追加到此 List 的尾部（可选操作）。
void add(int index,E element) 
在此列表中指定的位置插入指定的元素（可选操作）。
boolean addAll(int index,Collection<? extends E> c) 
将指定 collection 中的所有元素插入此列表的指定位置（可选操作）。
void clear() 
从此 collection 中移除所有元素（可选操作）。
boolean equals(Object o) 
将指定的对象与此列表进行相等性比较。
abstractE get(int index) 
返回此列表中指定位置处的元素。
int hashCode() 
返回此列表的哈希代码值。
int indexOf(Object o) 
返回此列表中首次出现指定元素的索引，如果列表中不包含此元素，则返回 -1。
Iterator<E> iterator() 
返回以正确顺序在此列表的元素上进行迭代的迭代器。
int lastIndexOf(Object o) 
返回此列表中最后出现指定元素的索引，如果列表中不包含此元素，则返回 -1。
ListIterator<E> listIterator() 
返回此列表中的元素的迭代器（按适当顺序）。
ListIterator<E> listIterator(int index) 
从列表中的指定位置开始，返回此列表中的元素的列表迭代器（按适当顺序）。
E remove(int index) 
移除此列表中指定位置处的元素（可选操作）。
protectedvoid removeRange(int fromIndex,int toIndex) 
从此列表中移除其索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
E set(int index,E element) 
将此列表中指定位置的元素替换为指定的元素（可选操作）。
List<E> subList(int fromIndex,int toIndex) 
返回此列表 fromIndex（包括）和 toIndex（不包括）之间部分的视图。
从类 java.util.AbstractCollection 继承的方法 
addAll,contains,containsAll,isEmpty,remove,removeAll,retainAll,size,toArray,toArray,toString 
从类 java.lang.Object 继承的方法 
clone,finalize,getClass,notify,notifyAll,wait,wait,wait 
从接口 java.util.List 继承的方法 
addAll,contains,containsAll,isEmpty,remove,removeAll,retainAll,size,toArray,toArray
字段详细信息
modCount
protected transient int modCount已从结构上修改 此列表的次数。从结构上修改是指更改列表的大小，或者以其他方式打乱列表，使正在进行的迭代产生错误的结果。
此字段由 iterator 和 listIterator 方法返回的迭代器和列表迭代器实现来使用。如果意外更改了此字段中的值，则迭代器（或列表迭代器）将抛出 ConcurrentModificationException 来响应 next、remove、previous、set 或 add 操作。在迭代期间面临并发修改时，它提供了快速失败 行为，而不是非确定性行为。
子类是否使用此字段是可选的。如果子类希望提供快速失败迭代器（和列表迭代器），则它只需在其 add(int,Object) 和 remove(int) 方法（以及它所重写的、导致列表结构上修改的任何其他方法）中增加此字段。对 add(int,Object) 或 remove(int) 的单个调用向此字段添加的数量不得超过 1，否则迭代器（和列表迭代器）将抛出虚假的 ConcurrentModificationExceptions。如果某个实现不希望提供快速失败迭代器，则可以忽略此字段。
构造方法详细信息
AbstractList
protected AbstractList（）单独的构造方法。（由子类构造方法调用，通常是隐式的。） 
方法详细信息 
add
public boolean add(E o）将指定的元素追加到此 List 的尾部（可选操作）。
此实现调用 add(size(),o）。
注意，除非重写 add(int,Object），否则此实现将抛出 UnsupportedOperationException。
指定者：
接口 Collection<E> 中的 add
指定者：
接口 List<E> 中的 add
覆盖：
类 AbstractCollection<E> 中的 add
参数：
o - 要追加到此列表的元素。
返回：
true（按照 Collection.add 的常规协定）。
抛出：
UnsupportedOperationException - 如果此 Set 不支持 add 方法。
ClassCastException - 如果指定元素的类不允许该元素添加到此 set 中。
IllegalArgumentException - 此元素的某方面不允许它添加到此 collection 中。
--------------------------------------------------------------------------------
get
public abstract E get(int index）返回此列表中指定位置处的元素。
指定者：
接口 List<E> 中的 get
参数：
index - 要返回的元素的索引。
返回：
列表中指定位置的元素。
抛出：
IndexOutOfBoundsException - 如果给定的索引超出范围 (index < 0 || index >= size（））。
--------------------------------------------------------------------------------
set
public E set(int index,
E element）将此列表中指定位置的元素替换为指定的元素（可选操作）。
此实现始终抛出 UnsupportedOperationException。
指定者：
接口 List<E> 中的 set
参数：
index - 要替换的元素的索引。
element - 要存储在指定位置的元素。
返回：
以前在指定位置处的元素。
抛出：
UnsupportedOperationException - 如果此 List 不支持 set 方法。
ClassCastException - 如果指定元素的类不允许该元素添加到此列表。
IllegalArgumentException - 如果指定元素的某方面不允许它添加到此列表。
IndexOutOfBoundsException - 如果指定的索引超出范围 (index < 0 || index >= size（））。
--------------------------------------------------------------------------------
add
public void add(int index,
E element）在此列表中指定的位置插入指定的元素（可选操作）。向右移动当前处于该位置的元素（如果有）和所有后续元素（将其索引加 1）。
此实现始终抛出 UnsupportedOperationException。
指定者：
接口 List<E> 中的 add
参数：
index - 要插入指定元素的位置索引。
element - 要插入的元素。
抛出：
UnsupportedOperationException - 如果此 List 不支持 add 方法。
ClassCastException - 如果指定元素的类不允许该元素添加到此列表。
IllegalArgumentException - 如果指定元素的某方面不允许它添加到此列表。
IndexOutOfBoundsException - 索引超出范围 (index < 0 || index > size（））。
--------------------------------------------------------------------------------
remove
public E remove(int index）移除此列表中指定位置处的元素（可选操作）。向左移动所有后续元素（将其索引减 1）。返回从列表中移除的元素。
此实现始终抛出 UnsupportedOperationException。
指定者：
接口 List<E> 中的 remove
参数：
index - 要移除的元素的索引。
返回：
以前在指定位置处的元素。
抛出：
UnsupportedOperationException - 如果此 List 不支持 remove 方法。
IndexOutOfBoundsException - 如果指定的索引超出范围 (index < 0 || index >= size（））。
--------------------------------------------------------------------------------
indexOf
public int indexOf(Object o）返回此列表中首次出现指定元素的索引，如果列表中不包含此元素，则返回 -1。更正式地说，返回满足以下条件的最低索引 i：（o==null get(i)==null :o.equals(get(i)))，如果没有满足此条件的索引，则返回 -1。
此实现首先获取一个列表迭代器（使用 listIterator（））。然后它迭代列表，直至找到指定的元素，或者到达列表的末尾。
指定者：
接口 List<E> 中的 indexOf
参数：
o - 要搜索的元素。
返回：
此列表中首次出现指定元素的索引，如果列表中不包含此元素，则返回 -1。
--------------------------------------------------------------------------------
lastIndexOf
public int lastIndexOf(Object o）返回此列表中最后出现指定元素的索引，如果列表中不包含此元素，则返回 -1。更正式地说，返回满足以下条件的最高索引 i：（o==null get(i)==null :o.equals(get(i)))，如果没有满足此条件的此索引，则返回 -1。
此实现首先获取一个指向列表末尾的列表迭代器（使用 listIterator(size（）））。然后它反向迭代列表，直至找到指定的元素，或者到达列表的开头。
指定者：
接口 List<E> 中的 lastIndexOf
参数：
o - 要搜索的元素。
返回：
此列表中最后出现指定元素的索引，如果列表中不包含此元素，则返回 -1。
--------------------------------------------------------------------------------
clear
public void clear（）从此 collection 中移除所有元素（可选操作）。此调用返回后，该 collection 将为空（除非它抛出异常）。
此实现调用 removeRange(0,size（））。
注意，除非重写 remove(int index) 或 removeRange(int fromIndex,int toIndex），否则此实现将抛出 UnsupportedOperationException。
指定者：
接口 Collection<E> 中的 clear
指定者：
接口 List<E> 中的 clear
覆盖：
类 AbstractCollection<E> 中的 clear
抛出：
UnsupportedOperationException - 如果此 Collection 不支持 clear 方法。
--------------------------------------------------------------------------------
addAll
public boolean addAll(int index,
Collection<? extends E> c）将指定 collection 中的所有元素插入此列表的指定位置（可选操作）。向右移动当前处于该位置的元素（如果有）和所有后续元素（增加其索引）。新元素将按由指定 collection 的迭代器所返回的顺序出现在列表中。如果在该操作进行过程中修改了指定的 collection，则未指定此操作的行为。（注意，如果指定的 collection 为此列表，而且该列表非空，则会发生此行为。）
此实现获取指定 collection 上的迭代器，且迭代此 collection，并使用 add(int,Object) 将迭代器获取的元素插入此列表的适当位置，一次插入一个。为了提高效率，多数实现将重写此方法。
注意，除非重写 add(int,Object），否则此实现将抛出 UnsupportedOperationException。
指定者：
接口 List<E> 中的 addAll
参数：
index - 在其中插入指定 collection 中第一个元素的索引。
c - 要插入此列表的元素。
返回：
如果此列表由于此方法的调用而发生改变，则返回 true。
抛出：
UnsupportedOperationException - 如果此列表不支持 addAll 方法。
ClassCastException - 如果指定 collection 的元素的类不允许该元素添加到此 List 中。
IllegalArgumentException - 指定 collection 的元素的某方面不允许它添加到此 List 中。
IndexOutOfBoundsException - 索引超出范围 (index < 0 || index > size（））。
NullPointerException - 如果指定的 collection 为 null。
--------------------------------------------------------------------------------
iterator
public Iterator<E> iterator（）返回以正确顺序在此列表的元素上进行迭代的迭代器。
此实现返回 iterator 接口的一个直接实现，具体取决于底层 list 的 size（）、get(int) 和 remove(int) 方法。
注意，除非重写该列表的 remove(int) 方法，否则此方法返回的迭代器将抛出一个 UnsupportedOperationException 来响应其 remove 方法。
在面临并发修改时，可以使此实现抛出运行时异常，如 (protected) modCount 字段规范中的描述。
指定者：
接口 Iterable<E> 中的 iterator
指定者：
接口 Collection<E> 中的 iterator
指定者：
接口 List<E> 中的 iterator
指定者：
类 AbstractCollection<E> 中的 iterator
返回：
以正确顺序在此列表的元素上进行迭代的迭代器。
另请参见：
modCount
--------------------------------------------------------------------------------
listIterator
public ListIterator<E> listIterator（）返回此列表中的元素的迭代器（按适当顺序）。此实现返回 listIterator(0）。
指定者：
接口 List<E> 中的 listIterator
返回：
此列表中的元素的迭代器（按适当顺序）。
另请参见：
listIterator(int)
--------------------------------------------------------------------------------
listIterator
public ListIterator<E> listIterator(int index）从列表中的指定位置开始，返回此列表中的元素的列表迭代器（按适当顺序）。指定的索引指示初始调用 next 方法将返回的第一个元素。对 previous 方法的初始调用将返回指定索引减 1 处的元素。
此实现返回 ListIterator 接口的直接实现，扩展了由 iterator() 方法返回的 Iterator 接口的实现。ListIterator 实现依赖于底层 list 的 get(int）、set(int,Object）、add(int,Object) 和 remove(int) 方法。
注意，除非重写列表的 remove(int）、set(int,Object) 和 add(int,Object) 方法，否则此实现返回的列表迭代器将抛出 UnsupportedOperationException 来响应其 remove、set 和 add。
在面临并发修改时，可以使此实现抛出运行时异常，如 (protected) modCount 字段规范中的描述。
指定者：
接口 List<E> 中的 listIterator
参数：
index - 要从列表迭代器返回的第一个元素的索引（通过调用 next 方法）。
返回：
此列表中的元素的列表迭代器（按适当顺序），而且从列表中的指定位置开始。
抛出：
IndexOutOfBoundsException - 如果指定的索引超出范围 (index < 0 || index > size（））。
另请参见：
modCount
--------------------------------------------------------------------------------
subList
public List<E> subList(int fromIndex,
int toIndex）返回此列表 fromIndex（包括）和 toIndex（不包括）之间部分的视图。（如果 fromIndex 和 toIndex 相等，则返回的列表为空。）返回的列表由此列表支持，因此返回列表中的更改将反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。
此方法省去了显式范围操作（此操作通常针对数组存在）。通过操作 subList 视图而非整个列表，期望列表的任何操作可用作范围操作。例如，下面的语句从列表中移除了某个范围内的元素：
list.subList(from,to).clear();
可以对 indexOf 和 lastIndexOf 构造类似的语句，而且 Collections 类中的所有算法都可以应用于 subList。
如果以任何其他方式（而不是通过返回的列表）从结构上修改 了底层列表（即此列表），则此方法返回的列表语义将变为未定义。（从结构上修改是指更改列表的大小，或者以其他方式打乱列表，使正在进行的迭代产生错误的结果。）
此实现返回一个为 AbstractList 创建子类的列表。子类在 private 字段中存储底层列表中 subList 的偏移量、subList 的大小（随其生存期而变化）以及底层列表的预期 modCount 值。子类有两个变体，其中一个实现 RandomAccess。如果此列表实现 RandomAccess，则返回的列表将为实现 RandomAccess 的一个子类实例。
子类的 set(int,Object）、get(int）、add(int,Object）、remove(int）、addAll(int,Collection) 和 removeRange(int,int) 方法在对索引进行边界检查和调整偏移量之后，都委托给底层抽象列表上的相应方法。addAll(Collection c) 方法仅返回 addAll(size,c）。
listIterator(int) 方法返回底层列表的列表迭代器上的“包装器对象”，使用底层列表上的相应方法创建该迭代器。iterator 方法仅返回 listIterator（），且 size 方法仅返回子类的 size 字段。
所有方法都将首先检查底层列表的实际 modCount 是否与其预期的值相等，并且在不相等时将抛出 ConcurrentModificationException。
指定者：
接口 List<E> 中的 subList
参数：
fromIndex - subList 的低端点（包括）。
toIndex - subList 的高端点（不包括）。
返回：
列表中指定范围的视图。
抛出：
IndexOutOfBoundsException - 端点索引值超出范围 (fromIndex < 0 || toIndex > size) 
IllegalArgumentException - 端点索引顺序颠倒 (fromIndex > toIndex)
--------------------------------------------------------------------------------
equals
public boolean equals(Object o）将指定的对象与此列表进行相等性比较。当且仅当指定的对象也是一个列表，两个列表具有相同的大小，而且两个列表中所有相应的元素对都相等 时，才返回 true。（如果 (e1==null e2==null :e1.equals(e2）），则元素 e1 和 e2 相等。）换句话说，如果两个列表包含相同的元素，且元素的顺序也相同，才将它们定义为相等。
此实现首先检查指定的对象是否为此列表。如果是，则返回 true；否则，它将检查指定的对象是否为一个列表。如果不是，它将返回 false；如果是，它将迭代两个列表，比较相应的元素对。如果有任何比较结果返回 false，则此方法将返回 false。如果某中某个迭代器在另一迭代器之前完全迭代元素，则会返回 false（因为列表是不等长的）；否则，在迭代完成时将返回 true。
指定者：
接口 Collection<E> 中的 equals
指定者：
接口 List<E> 中的 equals
覆盖：
类 Object 中的 equals
参数：
o - 与此列表进行相等性比较的对象。
返回：
如果指定对象与此列表相等，则返回 true。
另请参见：
Object.hashCode(),Hashtable
--------------------------------------------------------------------------------
hashCode
public int hashCode（）返回此列表的哈希代码值。
此实现准确使用在 List.hashCode 方法的文档中用于定义列表哈希函数的代码。
指定者：
接口 Collection<E> 中的 hashCode
指定者：
接口 List<E> 中的 hashCode
覆盖：
类 Object 中的 hashCode
返回：
此列表的哈希代码值。
另请参见：
Object.equals(java.lang.Object),Hashtable
--------------------------------------------------------------------------------
removeRange
protected void removeRange(int fromIndex,
int toIndex）从此列表中移除其索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。向左移动所有后续元素（减小其索引）。此调用缩短了 ArrayList，将其减少了 (toIndex - fromIndex) 个元素。（如果 toIndex==fromIndex，则此操作无效。）
此方法由此列表及其 subList 上的 clear 操作调用。重写此方法以利用内部列表实现可以极大地 改进此列表及其 subList 上 clear 操作的性能。
此实现获取一个在 fromIndex 之前放置的列表迭代器，并在移除该范围内的元素前重复调用 ListIterator.next（后跟 ListIterator.remove）。注：如果 ListIterator.remove 需要线性时间，则此实现需要平方时间。
参数：
fromIndex - 要移除的第一个元素的索引。
toIndex - 要移除的最后一个元素之后的索引。