鸿蒙OS AbstractList

AbstractList

java.lang.Object

|—java.util.AbstractCollection<E&

|—|—java.util.AbstractList<E&

public abstract class AbstractList<E>
extends AbstractCollection<E>
implements List<E>

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

要实现一个不可修改的列表，程序员只需要扩展这个类并提供 get(int) 和 List#size() 方法的实现。

要实现一个可修改的列表，程序员必须另外重写 set(int, E) 方法（否则会抛出 UnsupportedOperationException）。如果列表是可变大小的，则程序员必须另外覆盖 add(int, E) 和 remove(int) 方法。

根据 Collection 接口规范中的建议，程序员通常应该提供一个 void（无参数）和集合构造函数。

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

此类中每个非抽象方法的文档都详细描述了它的实现。如果正在实现的集合允许更有效的实现，则可以覆盖这些方法中的每一个。

此类是 Java 集合框架的成员。

字段摘要

构造函数摘要

方法总结

字段详细信息

modCount

protected transient int modCount

此列表在结构上被修改的次数。结构修改是那些改变列表大小的修改，或者以其他方式扰乱它，使得正在进行的迭代可能产生不正确的结果。

该字段由 iterator 和 listIterator 方法返回的迭代器和列表迭代器实现使用。如果此字段的值意外更改，迭代器（或列表迭代器）将抛出 ConcurrentModificationException 以响应下一个、删除、上一个、设置或添加操作。这提供了快速失败的行为，而不是面对迭代期间的并发修改时的不确定行为。

子类对该字段的使用是可选的。如果一个子类希望提供快速失败的迭代器（和列表迭代器），那么它只需要在其 add(int, E) 和 remove(int) 方法（以及它覆盖的任何其他导致结构列表的修改）。对 add(int, E) 或 remove(int) 的单个调用必须向该字段添加不超过一个，否则迭代器（和列表迭代器）将抛出虚假的 ConcurrentModificationExceptions。如果实现不希望提供快速失败的迭代器，则可以忽略此字段。

构造函数详细信息

AbstractList

protected AbstractList()

唯一的构造函数。 （用于子类构造函数的调用，通常是隐式的。）

方法详情

add

public boolean add(E e)

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

支持此操作的列表可能会限制可以添加到此列表的元素。 特别是，一些列表会拒绝添加空元素，而另一些列表则会对可能添加的元素类型施加限制。 列表类应在其文档中明确指定对可以添加哪些元素的任何限制。

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

请注意，除非 add(int, E) 被覆盖，否则此实现将引发 UnsupportedOperationException。

指定者：

添加接口CollectionE

指定者：

添加接口ListE

覆盖：

添加类 AbstractCollectionE

参数：

返回:

true（由 Collection#add 指定）

Throws:

get

public abstract E get(int index)

返回此列表中指定位置的元素。

指定者：

进入接口 ListE

参数：

返回:

此列表中指定位置的元素

Throws:

set

public E set(int index, E element)

将此列表中指定位置的元素替换为指定元素（可选操作）。

此实现总是抛出 UnsupportedOperationException。

指定者：

在接口 ListE 中设置

参数：

返回:

先前在指定位置的元素

Throws:

add

public void add(int index, E element)

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

此实现总是抛出 UnsupportedOperationException。

指定者：

添加接口ListE

参数：

Throws:

remove

public E remove(int index)

移除此列表中指定位置的元素（可选操作）。 将任何后续元素向左移动（从它们的索引中减去 1）。 返回从列表中删除的元素。

此实现总是抛出 UnsupportedOperationException。

指定者：

在接口 ListE 中删除

参数：

返回:

先前在指定位置的元素

Throws:

indexOf

public int indexOf(Object o)

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

这个实现首先得到一个列表迭代器（使用 listIterator()）。 然后，它遍历列表，直到找到指定的元素或到达列表的末尾。

指定者：

接口 ListE 中的 indexOf

参数：

返回:

此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则为 -1

Throws:

lastIndexOf

public int lastIndexOf(Object o)

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

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

指定者：

接口 ListE 中的 lastIndexOf

参数：

返回:

此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则为 -1

Throws:

clear

public void clear()

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

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

请注意，此实现抛出 UnsupportedOperationException 除非 remove(int index) 或 removeRange(int fromIndex, int toIndex) 被覆盖。

指定者：

在界面 CollectionE 中清除

指定者：

在接口 ListE 中清除

覆盖：

在类 AbstractCollectionE 中清除

Throws:

addAll

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

将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。新元素将按照指定集合的迭代器返回的顺序出现在此列表中。如果在操作正在进行时修改了指定的集合，则此操作的行为是未定义的。 （请注意，如果指定的集合是这个列表，并且它是非空的，则会发生这种情况。）

此实现在指定集合上获取一个迭代器并对其进行迭代，使用 add(int, E) 将从迭代器获得的元素插入到此列表中的适当位置，一次一个。许多实现将覆盖此方法以提高效率。

请注意，除非 add(int, E) 被覆盖，否则此实现将引发 UnsupportedOperationException。

指定者：

接口 ListE 中的 addAll

参数：

返回:

如果此列表因调用而更改，则为 true

Throws:

iterator

public IteratorE iterator()

以正确的顺序返回此列表中元素的迭代器。

此实现返回迭代器接口的简单实现，依赖于后备列表的 size()、get(int) 和 remove(int) 方法。

请注意，此方法返回的迭代器将抛出 UnsupportedOperationException 以响应其 remove 方法，除非列表的 remove(int) 方法被覆盖。

可以使此实现在面对并发修改时抛出运行时异常，如（受保护的）modCount 字段的规范中所述。

指定者：

接口 CollectionE 中的迭代器

指定者：

接口 IterableE 中的迭代器

指定者：

接口 ListE 中的迭代器

指定者：

AbstractCollectionE 类中的迭代器

返回:

以正确顺序遍历此列表中的元素的迭代器

listIterator

public ListIteratorE listIterator()

返回此列表中元素的列表迭代器（以正确的顺序）。

此实现返回 listIterator(0)。

指定者：

接口 ListE 中的 listIterator

返回:

此列表中元素的列表迭代器（按正确顺序）

listIterator

public ListIteratorE listIterator(int index)

返回此列表中元素的列表迭代器（以正确的顺序），从列表中的指定位置开始。指定的索引指示初始调用 ListIterator#next 将返回的第一个元素。对 ListIterator#previous 的初始调用将返回具有指定索引减一的元素。

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

请注意，此实现返回的列表迭代器将抛出 UnsupportedOperationException 以响应其 remove、set 和 add 方法，除非列表的 remove(int)、set(int, E) 和 add(int, E) 方法被覆盖。

可以使此实现在面对并发修改时抛出运行时异常，如（受保护的）modCount 字段的规范中所述。

指定者：

接口 ListE 中的 listIterator

参数：

返回:

此列表中元素的列表迭代器（按正确顺序），从列表中的指定位置开始

Throws:

subList

public ListE subList(int fromIndex, int toIndex)

返回此列表在指定的 fromIndex（包括）和 toIndex（不包括）之间的部分的视图。 （如果 fromIndex 和 toIndex 相等，则返回列表为空。）返回列表由此列表支持，因此返回列表中的非结构性更改会反映在此列表中，反之亦然。 返回的列表支持此列表支持的所有可选列表操作。

这种方法消除了显式范围操作的需要（通常存在于数组中的那种）。 通过传递 subList 视图而不是整个列表，任何需要列表的操作都可以用作范围操作。 例如，以下习惯用法从列表中删除一系列元素：

      list.subList(from, to).clear(); 

可以为 indexOf 和 lastIndexOf 构造类似的习语，并且 Collections 类中的所有算法都可以应用于子列表。

如果后备列表（即此列表）以除通过返回列表之外的任何方式进行结构修改，则此方法返回的列表的语义将变为未定义。 （结构修改是改变这个列表的大小，或者以其他方式扰乱它，使得正在进行的迭代可能会产生不正确的结果。）

此实现返回一个子类 AbstractList 的列表。子类在私有字段中存储子列表在后备列表中的偏移量、子列表的大小（可以在其生命周期内更改）以及后备列表的预期 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。

指定者：

接口 ListE 中的子列表

参数：

返回:

此列表中指定范围的视图

Throws:

equals

public boolean equals(Object o)

比较指定对象与此列表是否相等。当且仅当指定对象也是一个列表时返回 true，两个列表具有相同的大小，并且两个列表中所有对应的元素对都相等。 （如果 (e1==null ? e2==null : e1.equals(e2)) 两个元素 e1 和 e2 相等。）换句话说，如果两个列表以相同的顺序包含相同的元素，则它们被定义为相等.

这个实现首先检查指定的对象是否是这个列表。如果是，则返回 true；如果不是，它检查指定的对象是否是一个列表。如果不是，则返回 false；如果是这样，它会遍历两个列表，比较相应的元素对。如果任何比较返回 false，则此方法返回 false。如果其中一个迭代器在另一个迭代器之前用完元素，则返回 false（因为列表的长度不等）；否则在迭代完成时返回 true。

指定者：

接口 CollectionE 中的等于

指定者：

接口 ListE 中的等于

覆盖：

类 Object 中的等于

参数：

返回:

如果指定的对象等于此列表，则为 true

hashCode

public int hashCode()

返回此列表的哈希码值。

此实现完全使用用于在 List#hashCode 方法的文档中定义列表哈希函数的代码。

指定者：

接口 CollectionE 中的 hashCode

指定者：

接口 ListE 中的 hashCode

覆盖：

类 Object 中的 hashCode

返回:

此列表的哈希码值

removeRange

protected void removeRange(int fromIndex, int toIndex)

从此列表中删除索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。 将任何后续元素向左移动（减少它们的索引）。 此调用通过 (toIndex – fromIndex) 元素缩短列表。 （如果toIndex==fromIndex，则此操作无效。）

此方法由对该列表及其子列表的清除操作调用。 重写此方法以利用列表实现的内部结构可以显着提高此列表及其子列表上的清除操作的性能。

此实现获取一个位于 fromIndex 之前的列表迭代器，并重复调用 ListIterator.next 后跟 ListIterator.remove，直到整个范围都被删除。 注意：如果 ListIterator.remove 需要线性时间，则此实现需要二次时间。

参数：