Module java.base
Package java.util

Class AbstractList<E>

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
类型参数:
E - 此列表中元素的类型
所有实现的接口:
Iterable<E>, Collection<E>, List<E>, SequencedCollection<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 接口规范的建议。

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

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

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

自 JDK 版本:
1.2

  • Field Details

    • modCount

      protected transient int modCount
      此列表已经被 结构性修改 的次数。结构性修改是指改变列表大小或以其他方式扰乱列表，以致正在进行的迭代可能产生不正确的结果。

      此字段由 iterator 和 listIterator 方法返回的迭代器和列表迭代器实现使用。如果此字段的值意外更改，迭代器（或列表迭代器）将对 next、remove、previous、set 或 add 操作抛出 ConcurrentModificationException。这提供了 快速失败 行为，而不是在迭代过程中面对并发修改时的非确定性行为。

      子类使用此字段是可选的。 如果子类希望提供快速失败的迭代器（和列表迭代器），则只需在其 add(int, E) 和 remove(int) 方法中递增此字段（以及任何其他重写导致对列表进行结构性修改的方法）。对 add(int, E) 或 remove(int) 的单次调用必须最多将此字段加一，否则迭代器（和列表迭代器）将抛出虚假的 ConcurrentModificationExceptions。如果实现不希望提供快速失败的迭代器，则可以忽略此字段。

  • Constructor Details

    • AbstractList

      protected AbstractList()
      唯一构造函数。（通常由子类构造函数隐式调用。）

  • Method Details

    • add

      public boolean add(E e)
      将指定元素追加到列表末尾（可选操作）。

      支持此操作的列表可能会对可以添加到列表中的元素施加限制。特别是，某些列表将拒绝添加 null 元素，而其他列表将对可以添加的元素类型施加限制。列表类应在其文档中清楚指定可以添加的元素的任何限制。

      指定者:
      add 在接口 Collection<E> 中
      指定者:
      add 在接口 List<E> 中
      覆盖:
      add 在类 AbstractCollection<E> 中
      实现要求:
      此实现调用 add(size(), e)。

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

      参数:
      e - 要追加到此列表的元素
      返回:
      true（由 Collection.add(E) 指定）
      抛出:
      UnsupportedOperationException - 如果此列表不支持 add 操作
      ClassCastException - 如果指定元素的类别阻止将其添加到此列表
      NullPointerException - 如果指定元素为 null，且此列表不允许 null 元素
      IllegalArgumentException - 如果此元素的某些属性阻止将其添加到此列表

    • get

      public abstract E get(int index)
      返回列表中指定位置的元素。
      指定者:
      get 在接口 List<E> 中
      参数:
      index - 要返回的元素的索引
      返回:
      此列表中指定位置的元素
      抛出:
      IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index >= size()）

    • set

      public E set(int index, E element)
      用指定元素替换列表中指定位置的元素（可选操作）。
      指定者:
      set 在接口 List<E>中
      实现要求:
      此实现始终抛出UnsupportedOperationException。
      参数:
      index - 要替换的元素的索引
      element - 要存储在指定位置的元素
      返回值:
      先前在指定位置的元素
      抛出:
      UnsupportedOperationException - 如果此列表不支持set操作
      ClassCastException - 如果指定元素的类别阻止将其添加到此列表中
      NullPointerException - 如果指定元素为null且此列表不允许null元素
      IllegalArgumentException - 如果指定元素的某些属性阻止将其添加到此列表中
      IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index >= size()）

    • add

      public void add(int index, E element)
      在此列表中的指定位置插入指定的元素（可选操作）。将当前位于该位置的元素（如果有）和任何后续元素向右移动（将其索引加一）。
      指定者:
      add 在接口 List<E>中
      实现要求:
      此实现始终抛出UnsupportedOperationException。
      参数:
      index - 要插入指定元素的索引
      element - 要插入的元素
      抛出:
      UnsupportedOperationException - 如果此列表不支持add操作
      ClassCastException - 如果指定元素的类别阻止将其添加到此列表中
      NullPointerException - 如果指定元素为null且此列表不允许null元素
      IllegalArgumentException - 如果指定元素的某些属性阻止将其添加到此列表中
      IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index > size()）

    • remove

      public E remove(int index)
      删除此列表中指定位置的元素（可选操作）。将任何后续元素向左移动（从其索引中减去一）。返回从列表中删除的元素。
      指定者:
      remove 在接口 List<E>中
      实现要求:
      此实现始终抛出UnsupportedOperationException。
      参数:
      index - 要删除的元素的索引
      返回值:
      先前在指定位置的元素
      抛出:
      UnsupportedOperationException - 如果此列表不支持remove操作
      IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index >= size()）

    • indexOf

      public int indexOf(Object o)
      返回此列表中指定元素的第一次出现的索引，如果此列表不包含该元素，则返回-1。更正式地，返回最低索引i，使得Objects.equals(o, get(i))，如果没有这样的索引，则返回-1。
      指定者:
      indexOf 在接口 List<E>中
      实现要求:
      此实现首先获取一个列表迭代器（使用listIterator()）。然后，它在列表中迭代，直到找到指定元素或达到列表末尾。
      参数:
      o - 要搜索的元素
      返回值:
      此列表中指定元素的第一次出现的索引，如果此列表不包含该元素，则返回-1
      抛出:
      ClassCastException - 如果指定元素的类型与此列表不兼容（可选）
      NullPointerException - 如果指定元素为null且此列表不允许null元素（可选）

    • lastIndexOf

      public int lastIndexOf(Object o)
      返回此列表中指定元素的最后一次出现的索引，如果此列表不包含该元素，则返回-1。更正式地，返回最高索引i，使得Objects.equals(o, get(i))，如果没有这样的索引，则返回-1。
      指定者:
      lastIndexOf 在接口 List<E>中
      实现要求:
      此实现首先获取指向列表末尾的列表迭代器（使用listIterator(size())）。然后，它向后迭代列表，直到找到指定元素，或达到列表开头。
      参数:
      o - 要搜索的元素
      返回值:
      此列表中指定元素的最后一次出现的索引，如果此列表不包含该元素，则返回-1
      抛出:
      ClassCastException - 如果指定元素的类型与此列表不兼容（可选）
      NullPointerException - 如果指定元素为null且此列表不允许null元素（可选）

    • clear

      public void clear()
      从此列表中删除所有元素（可选操作）。此调用返回后，列表将为空。
      指定者:
      clear 在接口 Collection<E>中
      指定者:
      clear 在接口 List<E>中
      覆盖:
      clear 在类 AbstractCollection<E>中
      实现要求:
      此实现调用removeRange(0, size())。

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

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

    • addAll

      public boolean addAll(int index, Collection<? extends E> c)
      将指定集合中的所有元素插入到此列表的指定位置（可选操作）。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。新元素将按照指定集合的迭代器返回它们的顺序出现在此列表中。如果在操作进行时修改了指定集合，则此操作的行为是未定义的。（请注意，如果指定集合是此列表且非空，则会发生这种情况。）
      指定由：
      addAll 在接口 List<E>中
      实现要求：
      此实现获取指定集合上的迭代器，并对其进行迭代，逐个将从迭代器获取的元素插入到此列表中的适当位置，使用add(int, E)。许多实现将为了效率而重写此方法。

      请注意，除非覆盖add(int, E)，否则此实现会抛出UnsupportedOperationException。

      参数：
      index - 要将来自指定集合的第一个元素插入的索引
      c - 包含要添加到此列表中的元素的集合
      返回：
      如果调用导致此列表发生更改，则返回true
      抛出：
      UnsupportedOperationException - 如果此列表不支持addAll操作
      ClassCastException - 如果指定集合的元素的类别阻止将其添加到此列表中
      NullPointerException - 如果指定集合包含一个或多个空元素，而此列表不允许空元素，或者指定集合为空
      IllegalArgumentException - 如果指定集合的元素的某些属性阻止将其添加到此列表中
      IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index > size()）

    • iterator

      public Iterator<E> iterator()
      返回此列表中元素的迭代器，按正确顺序排列。
      指定由：
      iterator 在接口 Collection<E>中
      指定由：
      iterator 在接口 Iterable<E>中
      指定由：
      iterator 在接口 List<E>中
      指定由：
      iterator 在类 AbstractCollection<E>中
      实现要求：
      此实现返回迭代器接口的直接实现，依赖于支持列表的size()、get(int)和remove(int)方法。

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

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

      返回：
      返回此列表中元素的迭代器，按正确顺序排列

    • listIterator

      public ListIterator<E> listIterator()
      返回此列表中元素的列表迭代器（按正确顺序）。
      指定由：
      listIterator 在接口 List<E>中
      实现要求：
      此实现返回listIterator(0)。
      返回：
      返回此列表中元素的列表迭代器（按正确顺序）
      参见：

    • listIterator

      public ListIterator<E> listIterator(int index)
      返回此列表中元素的列表迭代器（按正确顺序），从列表中指定位置开始。指定的索引表示通过对next的初始调用将返回的第一个元素。对previous的初始调用将返回指定索引减一的元素。
      指定由：
      listIterator 在接口 List<E>中
      实现要求：
      此实现返回扩展iterator()方法返回的Iterator接口实现的ListIterator接口的直接实现。ListIterator实现依赖于支持列表的get(int)、set(int, E)、add(int, E)和remove(int)方法。

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

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

      参数：
      index - 要从列表迭代器返回的第一个元素的索引（通过调用next）
      返回：
      返回此列表中元素的列表迭代器（按正确顺序），从列表中指定位置开始
      抛出：
      IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index > size()）

    • subList

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

      此方法消除了对显式范围操作的需求（通常存在于数组中）。任何期望列表的操作都可以通过传递子列表视图而不是整个列表来作为范围操作使用。例如，以下习语从列表中删除一系列元素：

      
      list.subList(from, to).clear();
      可以为indexOf和lastIndexOf构造类似的习语，并且Collections类中的所有算法都可以应用于子列表。

      如果支持列表（即此列表）以除返回的列表之外的任何方式进行结构修改，则此方法返回的列表的语义将变得不确定。（结构修改是指更改此列表的大小，或以使进行中的迭代可能产生不正确结果的方式扰乱它。）

      指定由：
      subList 在接口 List<E>中
      实现要求：
      此实现返回一个子类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。

      参数：
      fromIndex - 子列表的低端点（包括）
      toIndex - 子列表的高端点（不包括）
      返回：
      返回此列表中指定范围的视图
      抛出：
      IndexOutOfBoundsException - 如果端点索引值超出范围(fromIndex < 0 || toIndex > size)
      IllegalArgumentException - 如果端点索引顺序不正确(fromIndex > toIndex)

    • equals

      public boolean equals(Object o)
      比较指定的对象与此列表是否相等。仅当指定的对象也是一个列表时返回true，两个列表的大小相同，并且两个列表中对应的元素对都是相等的时候才返回true。（两个元素e1和e2如果(e1==null ? e2==null : e1.equals(e2))则它们是相等的。）换句话说，如果两个列表包含相同顺序的相同元素，则定义这两个列表是相等的。
      指定者：
      equals 在接口 Collection<E>
      指定者：
      equals 在接口 List<E>
      覆盖：
      equals 在类 Object
      实现要求：
      此实现首先检查指定的对象是否为此列表。如果是，则返回true；如果不是，则检查指定的对象是否为列表。如果不是，则返回false；如果是，则迭代两个列表，比较对应的元素对。如果任何比较返回false，此方法将返回false。如果任一迭代器在另一个迭代器之前耗尽元素，则返回false（因为列表长度不相等）；否则，在迭代完成时返回true。
      参数：
      o - 与此列表比较相等的对象
      返回：
      如果指定的对象等于此列表，则返回true
      参见：

    • hashCode

      public int hashCode()
      返回此列表的哈希码值。
      指定者：
      hashCode 在接口 Collection<E>
      指定者：
      hashCode 在接口 List<E>
      覆盖：
      hashCode 在类 Object
      实现要求：
      此实现使用与在List.hashCode()方法的文档中用于定义列表哈希函数的代码完全相同。
      返回：
      此列表的哈希码值
      参见：

    • removeRange

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

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

      实现要求：
      此实现获取一个位于fromIndex之前的列表迭代器，并重复调用ListIterator.next，然后调用ListIterator.remove，直到整个范围被移除。注意：如果ListIterator.remove需要线性时间，则此实现需要二次时间。
      参数：
      fromIndex - 要删除的第一个元素的索引
      toIndex - 要删除的最后一个元素之后的索引