模块 java.base
包 java.util

类 AbstractList<E>

java.lang.Object
java.util.AbstractCollection <E>
java.util.AbstractList<E>
类型参数：
E - 此list中元素的类型
所有已实现的接口：
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（无参数）和集合构造函数。

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

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

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

自从：
1.2

  • 字段详细信息

    • modCount

      protected transient int modCount
      此list已出现的次数结构修改.结构修改是那些改变列表大小的修改，或者以其他方式扰乱列表，使得正在进行的迭代可能会产生不正确的结果。

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

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

  • 构造方法详细信息

    • AbstractList

      protected AbstractList()
      唯一的构造方法。 （对于子类构造方法的调用，通常是隐式的。）

  • 方法详情

    • add

      public boolean add(E  e)
      将指定的元素附加到此list的末尾（可选操作）。

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

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

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

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

    • get

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

    • set

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

    • add

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

    • remove

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

    • indexOf

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

    • lastIndexOf

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

    • clear

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

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

      抛出：
      UnsupportedOperationException - 如果此list不支持 clear 操作

    • addAll

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

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

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

    • iterator

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

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

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

      返回：
      按正确顺序遍历此list中的元素的迭代器

    • listIterator

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

    • listIterator

      public ListIterator <E > listIterator(int index)
      返回此list中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始。指定的索引指示将由对 next 的初始调用返回的第一个元素。对 previous 的初始调用将返回指定索引减一的元素。
      指定者：
      listIterator 在接口 List<E> 中
      实现要求：
      此实现返回 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 字段的规范中所述。

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

    • subList

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

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

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

      如果后备列表（即这个列表）是结构修改除了通过返回的列表以外的任何方式。 （结构修改是指那些改变此list大小的修改，或者以其他方式扰乱它，以至于正在进行的迭代可能会产生不正确的结果。）

      指定者：
      subList 在接口 List<E> 中
      实现要求：
      此实现返回一个子类 AbstractList 的列表。子类在私有字段中存储 subList 的大小（可以在其生命周期内更改）以及支持列表的预期 modCount 值。子类有两种变体，其中一种实现了 RandomAccess 。如果此list实现 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 - subList 的低端点（包括）
      toIndex - 子列表的高端点（不包括）
      返回：
      此list中指定范围的视图
      抛出：
      IndexOutOfBoundsException - 如果端点索引值超出范围 (fromIndex < 0 || toIndex > size)
      IllegalArgumentException - 如果端点索引乱序 (fromIndex > toIndex)

    • equals

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

    • hashCode

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

    • removeRange

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

      此方法由对此list及其子列表的clear 操作调用。覆盖此方法以利用列表实现的内部结构可以基本上提高 clear 操作在此list及其子列表上的性能。

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