模块 java.base
 java.util

类 ArrayList<E>

类型参数:
E - 此list中元素的类型
所有已实现的接口:
Serializable , Cloneable , Iterable<E> , Collection<E> , List<E> , RandomAccess
已知子类:
AttributeList , RoleList , RoleUnresolvedList

public class ArrayList<E> extends AbstractList <E> implements List <E>, RandomAccess , Cloneable , Serializable
List 接口的可调整大小数组实现。实现所有可选列表操作,并允许所有元素,包括 null 。除了实现 List 接口之外,此类还提供了一些方法来操纵内部用于存储列表的数组的大小。 (这个类大致等同于 Vector ,除了它是不同步的。)

sizeisEmptygetsetiteratorlistIterator 操作以恒定时间运行。 add 操作运行于摊销常数时间,即添加n个元素需要O(n)的时间。所有其他操作都以线性时间运行(粗略地说)。与 LinkedList 实现相比,常数因子较低。

每个 ArrayList 实例都有一个capacity.容量是用于存储列表中元素的数组的大小。它始终至少与列表大小一样大。当元素被添加到 ArrayList 时,它的容量会自动增长。除了添加一个元素具有恒定的摊销时间成本这一事实之外,没有具体说明增长策略的细节。

在使用 ensureCapacity 操作添加大量元素之前,应用程序可以增加 ArrayList 实例的容量。这可能会减少增量重新分配的数量。

请注意,此实现不是同步的。 如果多个线程同时访问一个 ArrayList 实例,并且至少有一个线程在结构上修改了列表,它必须外部同步。 (结构修改是任何添加或删除一个或多个元素,或显式调整支持数组大小的操作;仅仅设置元素的值不是结构修改。)这通常是通过同步某些自然封装元素的对象来实现的列表。如果不存在这样的对象,则应使用 Collections.synchronizedList 方法“包装”列表。这最好在创建时完成,以防止意外的不同步访问列表:

  List list = Collections.synchronizedList(new ArrayList(...));

此类的 iterator listIterator 方法返回的迭代器是 fail-fast :如果在创建迭代器后的任何时间以任何方式对列表进行结构修改,除了通过迭代器自己的 remove add 方法,迭代器将抛出 ConcurrentModificationException 。因此,面对并发修改,迭代器会快速干净地失败,而不是冒着在未来不确定的时间出现任意的、不确定的行为的风险。

请注意,无法保证迭代器的快速失败行为,因为一般来说,在存在非同步并发修改的情况下不可能做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此,编写依赖于此异常的正确性的程序是错误的:迭代器的快速失败行为应该只用于检测错误。

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

自从:
1.2
参见:
  • 字段摘要

    在类 java.util.AbstractList 中声明的字段

    modCount
  • 构造方法总结

    构造方法
    构造方法
    描述
    构造一个初始容量为 10 的空列表。
    ArrayList(int initialCapacity)
    构造一个具有指定初始容量的空列表。
    ArrayList(Collection<? extends E> c)
    构造一个包含指定集合元素的列表,按照集合迭代器返回元素的顺序。
  • 方法总结

    修饰符和类型
    方法
    描述
    void
    add(int index, E element)
    在此list中的指定位置插入指定元素。
    boolean
    add(E e)
    将指定的元素附加到此list的末尾。
    boolean
    addAll(int index, Collection<? extends E> c)
    将指定集合中的所有元素插入此list,从指定位置开始。
    boolean
    addAll(Collection<? extends E> c)
    将指定集合中的所有元素追加到此list的末尾,按照它们由指定集合的迭代器返回的顺序。
    void
    从此list中删除所有元素。
    返回此 ArrayList 实例的浅表副本。
    boolean
    如果此list包含指定元素,则返回 true
    void
    ensureCapacity(int minCapacity)
    如有必要,增加此 ArrayList 实例的容量,以确保它至少可以容纳最小容量参数指定的元素数。
    boolean
    比较指定对象与此list是否相等。
    void
    forEach(Consumer<? super E> action)
    Iterable 的每个元素执行给定的操作,直到处理完所有元素或操作引发异常。
    E
    get(int index)
    返回此list中指定位置的元素。
    int
    返回此list的哈希码值。
    int
    返回此list中指定元素第一次出现的索引,如果此list不包含该元素,则返回 -1。
    boolean
    如果此list不包含任何元素,则返回 true
    以正确的顺序返回此list中元素的迭代器。
    int
    返回此list中指定元素最后一次出现的索引,如果此list不包含该元素,则返回 -1。
    返回此list中元素的列表迭代器(以正确的顺序)。
    listIterator(int index)
    返回此list中元素的列表迭代器(以适当的顺序),从列表中的指定位置开始。
    E
    remove(int index)
    移除此list中指定位置的元素。
    boolean
    从此list中移除第一次出现的指定元素(如果存在)。
    boolean
    从此list中移除指定集合中包含的所有元素。
    boolean
    removeIf(Predicate<? super E> filter)
    移除此集合中满足给定谓词的所有元素。
    protected void
    removeRange(int fromIndex, int toIndex)
    从此list中删除索引介于 fromIndextoIndex 之间的所有元素,包括在内。
    boolean
    仅保留此list中包含在指定集合中的元素。
    E
    set(int index, E element)
    用指定元素替换此list中指定位置的元素。
    int
    size()
    返回此list中的元素数。
    在此list中的元素上创建 late-bindingfail-fast Spliterator
    subList(int fromIndex, int toIndex)
    返回此list中指定的 fromIndex(含)和 toIndex(不含)之间的部分的视图。
    返回一个数组,其中包含此list中按正确顺序(从第一个元素到最后一个元素)的所有元素。
    <T> T[]
    toArray(T[] a)
    以正确的顺序(从第一个元素到最后一个元素)返回一个包含此list中所有元素的数组;返回数组的运行时类型是指定数组的类型。
    void
    将此 ArrayList 实例的容量修剪为列表的当前大小。

    在类 java.util.AbstractList 中声明的方法

    equals, hashCode

    在类 java.util.AbstractCollection 中声明的方法

    containsAll, toString

    在类 java.lang.Object 中声明的方法

    finalize, getClass, notify, notifyAll, wait, wait, wait

    在接口 java.util.Collection 中声明的方法

    parallelStream, stream, toArray

    在接口 java.util.List 中声明的方法

    containsAll, replaceAll, sort
  • 构造方法详细信息

    • ArrayList

      public ArrayList(int initialCapacity)
      构造一个具有指定初始容量的空列表。
      参数:
      initialCapacity - 列表的初始容量
      抛出:
      IllegalArgumentException - 如果指定的初始容量为负
    • ArrayList

      public ArrayList()
      构造一个初始容量为 10 的空列表。
    • ArrayList

      public ArrayList(Collection <? extends E > c)
      构造一个包含指定集合元素的列表,按照集合迭代器返回元素的顺序。
      参数:
      c - 其元素要放入此list中的集合
      抛出:
      NullPointerException - 如果指定的集合为空
  • 方法详情

    • trimToSize

      public void trimToSize()
      将此 ArrayList 实例的容量修剪为列表的当前大小。应用程序可以使用此操作来最小化 ArrayList 实例的存储。
    • ensureCapacity

      public void ensureCapacity(int minCapacity)
      如有必要,增加此 ArrayList 实例的容量,以确保它至少可以容纳最小容量参数指定的元素数。
      参数:
      minCapacity - 所需的最小容量
    • size

      public int size()
      返回此list中的元素数。
      指定者:
      size 在接口 Collection<E>
      指定者:
      size 在接口 List<E>
      返回:
      此list中的元素数
    • isEmpty

      public boolean isEmpty()
      如果此list不包含任何元素,则返回 true
      指定者:
      isEmpty 在接口 Collection<E>
      指定者:
      isEmpty 在接口 List<E>
      重写:
      isEmpty 在类 AbstractCollection<E>
      返回:
      true 如果这个列表不包含任何元素
    • contains

      public boolean contains(Object  o)
      如果此list包含指定元素,则返回 true。更正式地说,返回 true 当且仅当此list包含至少一个元素 e 使得 Objects.equals(o, e)
      指定者:
      contains 在接口 Collection<E>
      指定者:
      contains 在接口 List<E>
      重写:
      contains 在类 AbstractCollection<E>
      参数:
      o - 要测试其在此list中是否存在的元素
      返回:
      true 如果这个列表包含指定的元素
    • indexOf

      public int indexOf(Object  o)
      返回此list中指定元素第一次出现的索引,如果此list不包含该元素,则返回 -1。更正式地说,返回最低索引 i 这样 Objects.equals(o, get(i)) ,或 -1 如果没有这样的索引。
      指定者:
      indexOf 在接口 List<E>
      重写:
      indexOf 在类 AbstractList<E>
      参数:
      o - 要搜索的元素
      返回:
      此list中指定元素第一次出现的索引,如果此list不包含该元素,则为 -1
    • lastIndexOf

      public int lastIndexOf(Object  o)
      返回此list中指定元素最后一次出现的索引,如果此list不包含该元素,则返回 -1。更正式地说,返回最高索引 i 这样 Objects.equals(o, get(i)) ,或者 -1 如果没有这样的索引。
      指定者:
      lastIndexOf 在接口 List<E>
      重写:
      lastIndexOf 在类 AbstractList<E>
      参数:
      o - 要搜索的元素
      返回:
      此list中指定元素最后一次出现的索引,如果此list不包含该元素,则为 -1
    • clone

      public Object  clone()
      返回此 ArrayList 实例的浅表副本。 (元素本身不会被复制。)
      重写:
      clone 在类 Object
      返回:
      这个 ArrayList 实例的克隆
      参见:
    • toArray

      public Object [] toArray()
      返回一个数组,其中包含此list中按正确顺序(从第一个元素到最后一个元素)的所有元素。

      返回的数组将是“安全的”,因为此list不维护对它的引用。 (换句话说,这个方法必须分配一个新数组)。调用者因此可以自由修改返回的数组。

      此方法充当基于数组和基于集合的 API 之间的桥梁。

      指定者:
      toArray 在接口 Collection<E>
      指定者:
      toArray 在接口 List<E>
      重写:
      toArray 在类 AbstractCollection<E>
      返回:
      按正确顺序包含此list中所有元素的数组
      参见:
    • toArray

      public <T> T[] toArray(T[] a)
      以正确的顺序(从第一个元素到最后一个元素)返回一个包含此list中所有元素的数组;返回数组的运行时类型是指定数组的类型。如果列表适合指定的数组,则在其中返回。否则,将使用指定数组的运行时类型和此list的大小分配一个新数组。

      如果列表适合指定的数组并有剩余空间(即数组的元素多于列表),则紧跟在集合末尾的数组中的元素将设置为 null 。 (这对于确定列表的长度很有用仅有的如果调用者知道列表不包含任何空元素。)

      指定者:
      toArray 在接口 Collection<E>
      指定者:
      toArray 在接口 List<E>
      重写:
      toArray 在类 AbstractCollection<E>
      类型参数:
      T - 包含集合的数组的组件类型
      参数:
      a - 列表元素要存储到的数组,如果它足够大的话;否则,为此分配一个相同运行时类型的新数组。
      返回:
      包含列表元素的数组
      抛出:
      ArrayStoreException - 如果指定数组的运行时类型不是此list中每个元素的运行时类型的超类型
      NullPointerException - 如果指定数组为空
    • get

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

      public E  set(int index, E  element)
      用指定元素替换此list中指定位置的元素。
      指定者:
      set 在接口 List<E>
      重写:
      set 在类 AbstractList<E>
      参数:
      index - 要替换的元素的索引
      element - 要存储在指定位置的元素
      返回:
      先前在指定位置的元素
      抛出:
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
    • add

      public boolean add(E  e)
      将指定的元素附加到此list的末尾。
      指定者:
      add 在接口 Collection<E>
      指定者:
      add 在接口 List<E>
      重写:
      add 在类 AbstractList<E>
      参数:
      e - 要附加到此list的元素
      返回:
      true(由 Collection.add(E) 指定)
    • add

      public void add(int index, E  element)
      在此list中的指定位置插入指定元素。将当前位于该位置的元素(如果有)和任何后续元素向右移动(将其索引加一)。
      指定者:
      add 在接口 List<E>
      重写:
      add 在类 AbstractList<E>
      参数:
      index - 要插入指定元素的索引
      element - 要插入的元素
      抛出:
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
    • remove

      public E  remove(int index)
      移除此list中指定位置的元素。将任何后续元素向左移动(从其索引中减去一个)。
      指定者:
      remove 在接口 List<E>
      重写:
      remove 在类 AbstractList<E>
      参数:
      index - 要删除的元素的索引
      返回:
      从列表中删除的元素
      抛出:
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
    • equals

      public boolean equals(Object  o)
      比较指定对象与此list是否相等。返回 true 当且仅当指定的对象也是一个列表,两个列表具有相同的大小,并且两个列表中所有对应的元素对都是equal(两个元素 e1e2equalif (e1==null ? e2==null : e1.equals(e2)) .) 换句话说,如果两个列表包含相同顺序的相同元素,则它们被定义为相等。
      指定者:
      equals 在接口 Collection<E>
      指定者:
      equals 在接口 List<E>
      重写:
      equals 在类 AbstractList<E>
      参数:
      o - 要与此list进行相等比较的对象
      返回:
      true 如果指定的对象等于这个列表
      参见:
    • hashCode

      public int hashCode()
      返回此list的哈希码值。
      指定者:
      hashCode 在接口 Collection<E>
      指定者:
      hashCode 在接口 List<E>
      重写:
      hashCode 在类 AbstractList<E>
      返回:
      此list的哈希码值
      参见:
    • remove

      public boolean remove(Object  o)
      从此list中移除第一次出现的指定元素(如果存在)。如果列表不包含该元素,则它不变。更正式地说,删除具有最低索引 i 的元素,这样 Objects.equals(o, get(i)) (如果存在这样的元素)。如果此list包含指定元素,则返回 true(或者等效地,如果此list因调用而更改)。
      指定者:
      remove 在接口 Collection<E>
      指定者:
      remove 在接口 List<E>
      重写:
      remove 在类 AbstractCollection<E>
      参数:
      o - 要从此list中删除的元素(如果存在)
      返回:
      true 如果这个列表包含指定的元素
    • clear

      public void clear()
      从此list中删除所有元素。此调用返回后列表将为空。
      指定者:
      clear 在接口 Collection<E>
      指定者:
      clear 在接口 List<E>
      重写:
      clear 在类 AbstractList<E>
    • addAll

      public boolean addAll(Collection <? extends E > c)
      将指定集合中的所有元素追加到此list的末尾,按照它们由指定集合的迭代器返回的顺序。如果在操作进行时修改了指定的集合,则此操作的行为是未定义的。 (这意味着如果指定的集合是这个列表并且这个列表是非空的,那么这个调用的行为是未定义的。)
      指定者:
      addAll 在接口 Collection<E>
      指定者:
      addAll 在接口 List<E>
      重写:
      addAll 在类 AbstractCollection<E>
      参数:
      c - 包含要添加到此list的元素的集合
      返回:
      true 如果此list因调用而更改
      抛出:
      NullPointerException - 如果指定的集合为空
      参见:
    • addAll

      public boolean addAll(int index, Collection <? extends E > c)
      将指定集合中的所有元素插入此list,从指定位置开始。将当前位于该位置的元素(如果有)和任何后续元素向右移动(增加它们的索引)。新元素将按照它们由指定集合的迭代器返回的顺序出现在列表中。
      指定者:
      addAll 在接口 List<E>
      重写:
      addAll 在类 AbstractList<E>
      参数:
      index - 从指定集合中插入第一个元素的索引
      c - 包含要添加到此list的元素的集合
      返回:
      true 如果此list因调用而更改
      抛出:
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
      NullPointerException - 如果指定的集合为空
    • removeRange

      protected void removeRange(int fromIndex, int toIndex)
      从此list中删除索引介于 fromIndextoIndex 之间的所有元素,包括在内。将任何后续元素向左移动(减少它们的索引)。此调用将列表缩短 (toIndex - fromIndex) 个元素。 (如果 toIndex==fromIndex ,此操作无效。)
      重写:
      removeRange 在类 AbstractList<E>
      参数:
      fromIndex - 要删除的第一个元素的索引
      toIndex - 要删除的最后一个元素之后的索引
      抛出:
      IndexOutOfBoundsException - 如果 fromIndextoIndex 超出范围 (fromIndex < 0 || toIndex > size() || toIndex < fromIndex)
    • removeAll

      public boolean removeAll(Collection <?> c)
      从此list中移除指定集合中包含的所有元素。
      指定者:
      removeAll 在接口 Collection<E>
      指定者:
      removeAll 在接口 List<E>
      重写:
      removeAll 在类 AbstractCollection<E>
      参数:
      c - 包含要从此list中删除的元素的集合
      返回:
      true 如果此list因调用而更改
      抛出:
      ClassCastException - 如果此list的元素类与指定集合不兼容 (optional)
      NullPointerException - 如果此list包含空元素并且指定的集合不允许空元素 (optional),或者如果指定的集合为空
      参见:
    • retainAll

      public boolean retainAll(Collection <?> c)
      仅保留此list中包含在指定集合中的元素。换句话说,从该列表中删除所有未包含在指定集合中的元素。
      指定者:
      retainAll 在接口 Collection<E>
      指定者:
      retainAll 在接口 List<E>
      重写:
      retainAll 在类 AbstractCollection<E>
      参数:
      c - 包含要保留在此list中的元素的集合
      返回:
      true 如果此list因调用而更改
      抛出:
      ClassCastException - 如果此list的元素类与指定集合不兼容 (optional)
      NullPointerException - 如果此list包含空元素并且指定的集合不允许空元素 (optional),或者如果指定的集合为空
      参见:
    • listIterator

      public ListIterator <E > listIterator(int index)
      返回此list中元素的列表迭代器(以适当的顺序),从列表中的指定位置开始。指定的索引指示将由对 next 的初始调用返回的第一个元素。对 previous 的初始调用将返回指定索引减一的元素。

      返回的列表迭代器是 快速失败

      指定者:
      listIterator 在接口 List<E>
      重写:
      listIterator 在类 AbstractList<E>
      参数:
      index - 从列表迭代器返回的第一个元素的索引(通过调用 next
      返回:
      列表中元素的列表迭代器(以适当的顺序),从列表中的指定位置开始
      抛出:
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
    • listIterator

      public ListIterator <E > listIterator()
      返回此list中元素的列表迭代器(以正确的顺序)。

      返回的列表迭代器是 快速失败

      指定者:
      listIterator 在接口 List<E>
      重写:
      listIterator 在类 AbstractList<E>
      返回:
      此list中元素的列表迭代器(按正确顺序)
      参见:
    • iterator

      public Iterator <E > iterator()
      以正确的顺序返回此list中元素的迭代器。

      返回的迭代器是 快速失败

      指定者:
      iterator 在接口 Collection<E>
      指定者:
      iterator 在接口 Iterable<E>
      指定者:
      iterator 在接口 List<E>
      重写:
      iterator 在类 AbstractList<E>
      返回:
      按正确顺序遍历此list中的元素的迭代器
    • subList

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

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

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

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

      指定者:
      subList 在接口 List<E>
      重写:
      subList 在类 AbstractList<E>
      参数:
      fromIndex - subList 的低端点(包括)
      toIndex - 子列表的高端点(不包括)
      返回:
      此list中指定范围的视图
      抛出:
      IndexOutOfBoundsException - 如果端点索引值超出范围 (fromIndex < 0 || toIndex > size)
      IllegalArgumentException - 如果端点索引乱序 (fromIndex > toIndex)
    • forEach

      public void forEach(Consumer <? super E > action)
      从接口 Iterable 复制的描述
      Iterable 的每个元素执行给定的操作,直到处理完所有元素或操作引发异常。如果指定了迭代顺序,则将按迭代顺序执行操作。操作抛出的异常被转发给调用者。

      如果操作执行修改元素的底层源的副作用,则此方法的行为是未指定的,除非重写类已指定并发修改策略。

      指定者:
      forEach 在接口 Iterable<E>
      参数:
      action - 对每个元素执行的操作
      抛出:
      NullPointerException - 如果指定的操作为空
    • spliterator

      public Spliterator <E > spliterator()
      在此list中的元素上创建 late-bindingfail-fast Spliterator

      Spliterator 报告 Spliterator.SIZED Spliterator.SUBSIZED Spliterator.ORDERED 。覆盖实施应记录附加特征值的报告。

      指定者:
      spliterator 在接口 Collection<E>
      指定者:
      spliterator 在接口 Iterable<E>
      指定者:
      spliterator 在接口 List<E>
      返回:
      a Spliterator 覆盖此list中的元素
      自从:
      1.8
    • removeIf

      public boolean removeIf(Predicate <? super E > filter)
      从接口 Collection 复制的描述
      移除此集合中满足给定谓词的所有元素。迭代期间或由谓词抛出的错误或运行时异常将传递给调用者。
      指定者:
      removeIf 在接口 Collection<E>
      参数:
      filter - 为要删除的元素返回 true 的谓词
      返回:
      true 如果删除了任何元素
      抛出:
      NullPointerException - 如果指定的过滤器为空