AbstractList

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

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 AbstractCollection<E>
implements List<E>

此类提供 List 接口的骨干实现，以最大限度地减少实现“随机访问”数据存储（如数组）支持的该接口所需的工作。对于连续的访问数据（如链表），应优先使用 AbstractSequentialList，而不是此类。

要实现不可修改的列表，编程人员只需扩展此类，并提供 get(int) 和 size() 方法的实现。

要实现可修改的列表，编程人员必须另外重写 set(int, E) 方法（否则将抛出 UnsupportedOperationException）。如果列表为可变大小，则编程人员必须另外重写 add(int, E) 和 remove(int) 方法。

按照 Collection 接口规范中的建议，编程人员通常应该提供一个 void（无参数）和 collection 构造方法。

与其他抽象 collection 实现不同，编程人员不必提供迭代器实现；迭代器和列表迭代器由此类在以下“随机访问”方法上实现：get(int)、set(int, E)、add(int, E) 和 remove(int)。

此类中每个非抽象方法的文档详细描述了其实现。如果要实现的 collection 允许更有效的实现，则可以重写所有这些方法。

此类是 Java Collections Framework 的成员。

从以下版本开始：: 1.2

字段摘要
`protected int`	`modCount` 已从结构上修改此列表的次数。

构造方法摘要
`protected`	`AbstractList()` 唯一的构造方法。

方法摘要
`boolean`	`add(E e)` 将指定的元素添加到此列表的尾部（可选操作）。
`void`	`add(int index, E element)` 在列表的指定位置插入指定元素（可选操作）。
`boolean`	`addAll(int index, Collection<? extends E> c)` 将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
`void`	`clear()` 从此列表中移除所有元素（可选操作）。
`boolean`	`equals(Object o)` 将指定的对象与此列表进行相等性比较。
`abstract E`	`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)` 移除列表中指定位置的元素（可选操作）。
`protected void`	`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, E) 和 remove(int) 方法（以及它所重写的、导致列表结构上修改的任何其他方法）中增加此字段。对 add(int, E) 或 remove(int) 的单个调用向此字段添加的数量不得超过 1，否则迭代器（和列表迭代器）将抛出虚假的 ConcurrentModificationExceptions。如果某个实现不希望提供快速失败迭代器，则可以忽略此字段。

构造方法详细信息

protected AbstractList()

唯一的构造方法。（由子类构造方法调用，通常是隐式的。）

方法详细信息

add

public boolean add(E e)

将指定的元素添加到此列表的尾部（可选操作）。

支持此操作的列表可能对列表可以添加的元素做出一些限制。具体来说，某些列表将拒绝添加 null 元素，另一些列表将在可以添加的元素类型上施加限制。List 类应该在它们的文档中明确指定可以添加何种元素的所有限制。

此实现调用 add(size(), e)。

注意，除非重写 add(int, E)，否则此实现将抛出 UnsupportedOperationException。

指定者：: 接口 Collection<E> 中的 add
指定者：: 接口 List<E> 中的 add
覆盖：: 类 AbstractCollection<E> 中的 add

参数：: e - 将添加到此列表的元素
返回：: true（正如 Collection.add(E) 所指定的那样）
抛出：: UnsupportedOperationException - 如果此列表不支持 add 操作; ClassCastException - 如果指定元素的类不允许将该元素添加到此列表; NullPointerException - 如果指定元素为 null 并且此列表不允许使用 null 元素; IllegalArgumentException - 如果此元素的某些属性不允许将该元素添加到此列表

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 - 如果列表不支持 set 操作

ClassCastException - 如果指定元素的类不允许它添加到此列表

NullPointerException - 如果指定的元素为 null，并且此列表不允许 null 元素

IllegalArgumentException - 如果指定元素的某些属性不允许它添加到此列表

IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

add

public void add(int index,
                E element)

在列表的指定位置插入指定元素（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。

此实现始终抛出 UnsupportedOperationException。

指定者：: 接口 List<E> 中的 add

参数：: index - 要在其中插入指定元素处的索引; element - 要插入的元素

抛出：

UnsupportedOperationException - 如果列表不支持 add 操作

ClassCastException - 如果指定元素的类不允许它添加到此列表

NullPointerException - 如果指定的元素为 null，并且此列表不允许 null 元素

IllegalArgumentException - 如果指定元素的某些属性不允许它添加到此列表

IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

remove

public E remove(int index)

移除列表中指定位置的元素（可选操作）。将所有的后续元素向左移动（将其索引减 1）。返回从列表中移除的元素。

此实现始终抛出 UnsupportedOperationException。

指定者：: 接口 List<E> 中的 remove

参数：: index - 要移除的元素的索引
返回：: 以前在指定位置的元素
抛出：: UnsupportedOperationException - 如果列表不支持 remove 操作; IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

indexOf

public int indexOf(Object o)

返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i；如果没有这样的索引，则返回 -1。

此实现首先获取一个列表迭代器（使用 listIterator()）。然后它迭代列表，直至找到指定的元素，或者到达列表的末尾。

指定者：: 接口 List<E> 中的 indexOf

参数：: o - 要搜索的元素
返回：: 此列表中第一次出现的指定元素的索引，如果列表不包含该元素，则返回 -1
抛出：: ClassCastException - 如果指定元素的类型和此列表不兼容（可选）; NullPointerException - 如果指定的元素是 null，并且此列表不允许 null 元素（可选）

lastIndexOf

public int lastIndexOf(Object o)

返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i；如果没有这样的索引，则返回 -1。

此实现首先获取一个指向列表末尾的列表迭代器（使用 listIterator(size())）。然后它逆向迭代列表，直至找到指定的元素，或者到达列表的开头。

指定者：: 接口 List<E> 中的 lastIndexOf

参数：: o - 要搜索的元素
返回：: 列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1
抛出：: ClassCastException - 如果指定元素的类型和此列表不兼容（可选）; NullPointerException - 如果指定的元素是 null，并且此列表不允许 null 元素（可选）

clear

public void clear()

从此列表中移除所有元素（可选操作）。此调用返回后，列表将为空。

此实现调用 removeRange(0, size())。

注意，除非重写 remove(int index) 或 removeRange(int fromIndex, int toIndex)，否则此实现将抛出 UnsupportedOperationException。

指定者：: 接口 Collection<E> 中的 clear
指定者：: 接口 List<E> 中的 clear
覆盖：: 类 AbstractCollection<E> 中的 clear

抛出：: UnsupportedOperationException - 如果此列表不支持 clear 操作。

addAll

public boolean addAll(int index,
                      Collection<? extends E> c)

将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（增加其索引）。新元素将按照它们通过指定 collection 的迭代器所返回的顺序出现在此列表中。如果在操作正在进行中修改了指定的 collection，那么该操作的行为是不确定的（注意，如果指定的 collection 是此列表，并且它是非空的，则会发生这种情况。）

此实现获取指定 collection 上的迭代器并迭代它，使用 add(int, E) 将迭代器获取的元素插入此列表的适当位置，一次一个。为了提高效率，多数实现将重写此方法。

注意，除非重写 add(int, E)，否则此实现将抛出 UnsupportedOperationException。

指定者：: 接口 List<E> 中的 addAll

参数：: index - 将指定 collection 的第一个元素所插入位置的索引; c - 包含要添加到此列表的元素的 collection

返回：

如果此列表由于调用而发生更改，则返回 true

抛出：

UnsupportedOperationException - 如果列表不支持 addAll 操作

ClassCastException - 如果指定 collection 中某个元素的类不允许它添加到此列表

NullPointerException - 如果指定的 collection 包含一个或多个 null 元素，并且该列表不允许 null 元素，或者指定的 collection 为 null

IllegalArgumentException - 如果指定 collection 的元素的某些属性不允许它添加到此列表

IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

iterator

public Iterator<E> iterator()

返回以恰当顺序在此列表的元素上进行迭代的迭代器。

此实现返回 iterator 接口的一个直接实现，具体取决于底层实现列表的 size()、get(int) 和 remove(int) 方法。

注意，除非重写列表的 remove(int) 方法，否则此方法返回的迭代器将抛出一个 UnsupportedOperationException 来响应其 remove 方法。

根据 (protected) modCount 字段规范中的描述，在面临并发修改时，可以使此实现抛出运行时异常。

指定者：: 接口 Iterable<E> 中的 iterator
指定者：: 接口 Collection<E> 中的 iterator
指定者：: 接口 List<E> 中的 iterator
指定者：: 类 AbstractCollection<E> 中的 iterator

返回：: 在此 collection 中的元素上进行迭代的迭代器。
另请参见：: modCount

listIterator

public ListIterator<E> listIterator()

返回此列表元素的列表迭代器（按适当顺序）。

指定者：: 接口 List<E> 中的 listIterator

返回：: 此列表中的元素的迭代器（按适当顺序）。
此实现返回 listIterator(0)。
另请参见：: listIterator(int)

listIterator

public ListIterator<E> listIterator(int index)

返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。指定的索引表示 next 的初始调用所返回的第一个元素。previous 方法的初始调用将返回索引比指定索引少 1 的元素。

此实现返回 ListIterator 接口的直接实现，扩展了由 iterator() 方法返回的 Iterator 接口的实现。ListIterator 实现依赖于底层实现列表的 get(int)、set(int, E)、add(int, E) 和 remove(int) 方法。

注意，除非重写列表的 remove(int)、set(int, E) 和 add(int, E) 方法，否则此实现返回的列表迭代器将抛出 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, E)、get(int)、add(int, E)、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 - 要移除的最后一个元素之后的索引。

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

java.util 类 AbstractList<E>

modCount

AbstractList

add

get

set

add

remove

indexOf

lastIndexOf

clear

addAll

iterator

listIterator

listIterator

subList

equals

hashCode

removeRange

java.util
类 AbstractList<E>