java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.ArrayList<E>

类型参数:: E - 此列表中元素的类型

所有实现的接口:: Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess, SequencedCollection<E>

直接已知的子类:: AttributeList, RoleList, RoleUnresolvedList

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

List接口的可调整大小数组实现。实现所有可选的列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供了用于操作内部用于存储列表的数组大小的方法。（此类大致相当于Vector，只是它是不同步的。）

size、isEmpty、get、set、iterator和listIterator操作在常数时间内运行。add操作在摊销的常数时间内运行，也就是说，添加n个元素需要O(n)的时间。所有其他操作在线性时间内运行（粗略地说）。与LinkedList实现相比，常数因子较低。

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

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

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

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

此类的iterator和listIterator方法返回的迭代器是快速失败的：如果在创建迭代器后的任何时间内以任何方式对列表进行结构修改，除了通过迭代器自身的remove或add方法之外，迭代器将抛出ConcurrentModificationException。因此，在面对并发修改时，迭代器会快速而干净地失败，而不是在未来的某个不确定时间冒险进行任意的、非确定性的行为。

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

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

自 JDK 版本:

1.2

参见:

Field Summary

Fields declared in class java.util.AbstractList
modCount
Constructor Summary

Constructors

Constructor

Description

ArrayList()

构造一个具有初始容量为十的空列表。

ArrayList(int initialCapacity)

构造一个具有指定初始容量的空列表。

ArrayList(Collection<? extends E> c)

构造一个包含指定集合元素的列表，顺序与集合的迭代器返回的顺序相同。
Method Summary

Modifier and Type

Method

Description

void

add(int index, E element)

在列表中的指定位置插入指定元素。

boolean

add(E e)

将指定元素追加到列表末尾。

boolean

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

从指定位置开始，将指定集合中的所有元素插入到此列表中。

boolean

addAll(Collection<? extends E> c)

将指定集合中的所有元素按照指定集合的迭代器返回的顺序追加到列表末尾。

void

addFirst(E element)

将一个元素作为此集合的第一个元素添加（可选操作）。

void

addLast(E element)

将一个元素作为此集合的最后一个元素添加（可选操作）。

void

clear()

从列表中移除所有元素。

Object

clone()

返回此ArrayList实例的浅拷贝。

boolean

contains(Object o)

如果此列表包含指定元素，则返回true。

void

ensureCapacity(int minCapacity)

如有必要，增加此ArrayList实例的容量，以确保其至少可以容纳由最小容量参数指定的元素数量。

boolean

equals(Object o)

将指定对象与此列表进行比较以测试相等性。

void

forEach(Consumer<? super E> action)

对Iterable的每个元素执行给定操作，直到所有元素都已处理或操作引发异常。

E

get(int index)

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

E

getFirst()

获取此集合的第一个元素。

E

getLast()

获取此集合的最后一个元素。

int

hashCode()

返回此列表的哈希码值。

int

indexOf(Object o)

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

boolean

isEmpty()

如果此列表不包含任何元素，则返回true。

Iterator<E>

iterator()

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

int

lastIndexOf(Object o)

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

ListIterator<E>

listIterator()

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

ListIterator<E>

listIterator(int index)

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

E

remove(int index)

移除列表中指定位置的元素。

boolean

remove(Object o)

如果存在，则从列表中移除指定元素的第一次出现。

boolean

removeAll(Collection<?> c)

从列表中移除包含在指定集合中的所有元素。

E

removeFirst()

移除并返回此集合的第一个元素（可选操作）。

boolean

removeIf(Predicate<? super E> filter)

移除此集合中满足给定谓词的所有元素。

E

removeLast()

移除并返回此集合的最后一个元素（可选操作）。

protected void

removeRange(int fromIndex, int toIndex)

从列表中移除索引位于fromIndex（包括）和toIndex（不包括）之间的所有元素。

boolean

retainAll(Collection<?> c)

仅保留此列表中包含在指定集合中的元素。

E

set(int index, E element)

用指定元素替换此列表中指定位置的元素。

int

size()

返回此列表中的元素数。

Spliterator<E>

spliterator()

在此列表中的元素上创建一个延迟绑定和快速失败的Spliterator。

List<E>

subList(int fromIndex, int toIndex)

返回此列表中位于指定fromIndex（包括）和toIndex（不包括）之间的部分的视图。

Object[]

toArray()

返回一个数组，其中包含此列表中所有元素的正确顺序（从第一个元素到最后一个元素）。

<T> T[]

toArray(T[] a)

返回一个数组，其中包含此列表中所有元素的正确顺序（从第一个元素到最后一个元素）；返回数组的运行时类型是指定数组的类型。

void

trimToSize()

将此ArrayList实例的容量修剪为列表的当前大小。

Methods declared in class java.util.AbstractList
equals, hashCode

Methods declared in class java.util.AbstractCollection
containsAll, toString

Methods declared in class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods declared in interface java.util.Collection
parallelStream, stream, toArray

Methods declared in interface java.util.List
containsAll, replaceAll, reversed, sort

Constructor Details
- ArrayList
  
  public ArrayList(int initialCapacity)
  
  构造一个具有指定初始容量的空列表。
  
  参数:
  
  initialCapacity - 列表的初始容量
  
  抛出:
  
  IllegalArgumentException - 如果指定的初始容量为负数
- ArrayList
  
  public ArrayList()
  
  构造一个具有初始容量为十的空列表。
- ArrayList
  
  public ArrayList(Collection<? extends E> c)
  
  构造一个包含指定集合元素的列表，顺序与集合的迭代器返回的顺序相同。
  
  参数:
  
  c - 要放入此列表中的元素的集合
  
  抛出:
  
  NullPointerException - 如果指定的集合为null
Method Details
- trimToSize
  
  public void trimToSize()
  
  将此ArrayList实例的容量调整为列表的当前大小。应用程序可以使用此操作来最小化ArrayList实例的存储。
- ensureCapacity
  
  public void ensureCapacity(int minCapacity)
  
  如有必要，增加此ArrayList实例的容量，以确保其至少可以容纳由最小容量参数指定的元素数量。
  
  参数:
  
  minCapacity - 所需的最小容量
- size
  
  public int size()
  
  返回此列表中的元素数。
  
  指定者:
  
  size 在接口 Collection<E>
  
  指定者:
  
  size 在接口 List<E>
  
  返回:
  
  此列表中的元素数
- isEmpty
  
  public boolean isEmpty()
  
  如果此列表不包含任何元素，则返回true。
  
  指定者:
  
  isEmpty 在接口 Collection<E>
  
  指定者:
  
  isEmpty 在接口 List<E>
  
  覆盖:
  
  isEmpty 在类 AbstractCollection<E>
  
  返回:
  
  如果此列表不包含任何元素，则返回true
- contains
  
  public boolean contains(Object o)
  
  如果此列表包含指定的元素，则返回true。更正式地说，仅当此列表包含至少一个元素e使得Objects.equals(o, e)时，才返回true。
  
  指定者:
  
  contains 在接口 Collection<E>
  
  指定者:
  
  contains 在接口 List<E>
  
  覆盖:
  
  contains 在类 AbstractCollection<E>
  
  参数:
  
  o - 要测试其在此列表中存在性的元素
  
  返回:
  
  如果此列表包含指定的元素，则返回true
- indexOf
  
  public int indexOf(Object o)
  
  返回此列表中指定元素的第一次出现的索引；如果此列表不包含该元素，则返回-1。更正式地说，返回最低索引i使得Objects.equals(o, get(i))，如果没有这样的索引则返回-1。
  
  指定者:
  
  indexOf 在接口 List<E>
  
  覆盖:
  
  indexOf 在类 AbstractList<E>
  
  参数:
  
  o - 要搜索的元素
  
  返回:
  
  返回此列表中指定元素的第一次出现的索引；如果此列表不包含该元素，则返回-1
- lastIndexOf
  
  public int lastIndexOf(Object o)
  
  返回此列表中指定元素的最后一次出现的索引；如果此列表不包含该元素，则返回-1。更正式地说，返回最高索引i使得Objects.equals(o, get(i))，如果没有这样的索引则返回-1。
  
  指定者:
  
  lastIndexOf 在接口 List<E>
  
  覆盖:
  
  lastIndexOf 在类 AbstractList<E>
  
  参数:
  
  o - 要搜索的元素
  
  返回:
  
  返回此列表中指定元素的最后一次出现的索引；如果此列表不包含该元素，则返回-1
- clone
  
  public Object clone()
  
  返回此ArrayList实例的浅拷贝。（元素本身不会被复制。）
  覆盖:
  
  clone 在类 Object
  
  返回:
  
  此ArrayList实例的克隆
  
  参见:
  
  Cloneable
- toArray
  
  public Object[] toArray()
  
  返回一个数组，其中包含此列表中所有元素的正确顺序（从第一个到最后一个元素）。
  返回的数组将是“安全”的，因为此列表不会保留对它的任何引用。（换句话说，此方法必须分配一个新数组。）因此，调用者可以自由修改返回的数组。
  
  此方法充当基于数组和基于集合的API之间的桥梁。
  指定者:
  
  toArray 在接口 Collection<E>
  
  指定者:
  
  toArray 在接口 List<E>
  
  覆盖:
  
  toArray 在类 AbstractCollection<E>
  
  返回:
  
  一个数组，其中包含此列表中所有元素的正确顺序
  
  参见:
  
  Arrays.asList(Object[])
- toArray
  
  public <T> T[] toArray(T[] a)
  
  返回一个数组，其中包含此列表中所有元素的正确顺序（从第一个到最后一个元素）；返回数组的运行时类型是指定数组的类型。如果列表适合指定的数组，则将其返回。否则，将使用指定数组的运行时类型和此列表的大小分配一个新数组。
  如果列表适合指定数组且有多余空间（即，数组的元素多于列表的元素），则数组中紧接在集合末尾的元素将设置为null。（仅当调用者知道列表不包含任何空元素时，此方法才有助于确定列表的长度。）
  
  指定者:
  
  toArray 在接口 Collection<E>
  
  指定者:
  
  toArray 在接口 List<E>
  
  覆盖:
  
  toArray 在类 AbstractCollection<E>
  
  类型参数:
  
  T - 包含集合的数组的组件类型
  
  参数:
  
  a - 要存储列表元素的数组，如果足够大；否则，将为此目的分配一个相同运行时类型的新数组。
  
  返回:
  
  包含列表元素的数组
  
  抛出:
  
  ArrayStoreException - 如果指定数组的运行时类型不是此列表中每个元素的运行时类型的超类型
  
  NullPointerException - 如果指定数组为null
- get
  
  public E get(int index)
  
  返回此列表中指定位置的元素。
  
  指定者:
  
  get 在接口 List<E>
  
  指定者:
  
  get 在类 AbstractList<E>
  
  参数:
  
  index - 要返回的元素的索引
  
  返回:
  
  此列表中指定位置的元素
  
  抛出:
  
  IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index >= size()）
- getFirst
  
  public E getFirst()
  
  获取此集合的第一个元素。
  
  指定者:
  
  getFirst 在接口 List<E>中
  
  指定者:
  
  getFirst 在接口 SequencedCollection<E>中
  
  返回:
  
  检索到的元素
  
  抛出:
  
  NoSuchElementException - 如果此集合为空
  
  自:
  
  21
- getLast
  
  public E getLast()
  
  获取此集合的最后一个元素。
  
  指定者:
  
  getLast 在接口 List<E>中
  
  指定者:
  
  getLast 在接口 SequencedCollection<E>中
  
  返回:
  
  检索到的元素
  
  抛出:
  
  NoSuchElementException - 如果此集合为空
  
  自:
  
  21
- set
  
  public E set(int index, E element)
  
  用指定元素替换此列表中指定位置的元素。
  
  指定者:
  
  set 在接口 List<E>中
  
  覆盖:
  
  set 在类 AbstractList<E>中
  
  参数:
  
  index - 要替换的元素的索引
  
  element - 要存储在指定位置的元素
  
  返回:
  
  先前在指定位置的元素
  
  抛出:
  
  IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index >= size()）
- add
  
  public boolean add(E e)
  
  将指定元素追加到此列表的末尾。
  
  指定者:
  
  add 在接口 Collection<E>中
  
  指定者:
  
  add 在接口 List<E>中
  
  覆盖:
  
  add 在类 AbstractList<E>中
  
  参数:
  
  e - 要追加到此列表的元素
  
  返回:
  
  true（由Collection.add(E)指定）
- add
  
  public void add(int index, E element)
  
  在此列表中指定位置插入指定元素。将当前在该位置的元素（如果有）和任何后续元素向右移动（将它们的索引加一）。
  
  指定者:
  
  add 在接口 List<E>中
  
  覆盖:
  
  add 在类 AbstractList<E>中
  
  参数:
  
  index - 要插入指定元素的索引
  
  element - 要插入的元素
  
  抛出:
  
  IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index > size()）
- addFirst
  
  public void addFirst(E element)
  
  将元素添加为此集合的第一个元素（可选操作）。此操作正常完成后，给定元素将成为此集合的成员，并且它将是遇到顺序中的第一个元素。
  
  指定者:
  
  addFirst 在接口 List<E>中
  
  指定者:
  
  addFirst 在接口 SequencedCollection<E>中
  
  参数:
  
  element - 要添加的元素
  
  自:
  
  21
- addLast
  
  public void addLast(E element)
  
  将元素添加为此集合的最后一个元素（可选操作）。此操作正常完成后，给定元素将成为此集合的成员，并且它将是遇到顺序中的最后一个元素。
  
  指定者:
  
  addLast 在接口 List<E>中
  
  指定者:
  
  addLast 在接口 SequencedCollection<E>中
  
  参数:
  
  element - 要添加的元素。
  
  自:
  
  21
- remove
  
  public E remove(int index)
  
  删除此列表中指定位置的元素。将任何后续元素向左移动（从它们的索引中减去一个）。
  
  指定者:
  
  remove 在接口 List<E>中
  
  覆盖:
  
  remove 在类 AbstractList<E>中
  
  参数:
  
  index - 要移除的元素的索引
  
  返回:
  
  从列表中移除的元素
  
  抛出:
  
  IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index >= size()）
- removeFirst
  
  public E removeFirst()
  
  删除并返回此集合的第一个元素（可选操作）。
  
  指定者:
  
  removeFirst 在接口 List<E>中
  
  指定者:
  
  removeFirst 在接口 SequencedCollection<E>中
  
  返回:
  
  被移除的元素
  
  抛出:
  
  NoSuchElementException - 如果此集合为空
  
  自:
  
  21
- removeLast
  
  public E removeLast()
  
  删除并返回此集合的最后一个元素（可选操作）。
  
  指定者:
  
  removeLast 在接口 List<E>中
  
  指定者:
  
  removeLast 在接口 SequencedCollection<E>中
  
  返回:
  
  被移除的元素
  
  抛出:
  
  NoSuchElementException - 如果此集合为空
  
  自:
  
  21
- equals
  
  public boolean equals(Object o)
  
  将指定对象与此列表进行比较以检查是否相等。仅当指定对象也是列表时，两个列表具有相同大小，并且两个列表中对应的元素对都是相等的时返回true。（两个元素e1和e2如果(e1==null ? e2==null : e1.equals(e2))则它们是相等的。）换句话说，如果两个列表包含相同顺序的相同元素，则定义它们相等。
  指定者:
  
  equals 在接口 Collection<E>中
  
  指定者:
  
  equals 在接口 List<E>中
  
  覆盖:
  
  equals 在类 AbstractList<E>中
  
  参数:
  
  o - 与此列表进行比较的对象
  
  返回值:
  
  如果指定的对象等于此列表，则返回true
  
  参见:
  
  Object.hashCode()
  
  HashMap
- hashCode
  
  public int hashCode()
  
  返回此列表的哈希码值。
  指定者:
  
  hashCode 在接口 Collection<E>中
  
  指定者:
  
  hashCode 在接口 List<E>中
  
  覆盖:
  
  hashCode 在类 AbstractList<E>中
  
  返回值:
  
  此列表的哈希码值
  
  参见:
  
  Object.equals(java.lang.Object)
  
  System.identityHashCode(java.lang.Object)
- remove
  
  public boolean remove(Object o)
  
  从此列表中删除指定元素的第一个出现，如果存在的话。如果列表不包含该元素，则不会更改。更正式地说，删除具有最低索引i的元素，使得Objects.equals(o, get(i))（如果存在这样的元素）。如果此列表包含指定的元素，则返回true（或者等效地，如果此列表由于调用而更改）。
  
  指定者:
  
  remove 在接口 Collection<E>中
  
  指定者:
  
  remove 在接口 List<E>中
  
  覆盖:
  
  remove 在类 AbstractCollection<E>中
  
  参数:
  
  o - 如果存在，则从此列表中删除的元素
  
  返回值:
  
  如果此列表包含指定的元素，则返回true
- clear
  
  public void clear()
  
  从此列表中删除所有元素。此调用返回后，列表将为空。
  
  指定者:
  
  clear 在接口 Collection<E>中
  
  指定者:
  
  clear 在接口 List<E>中
  
  覆盖:
  
  clear 在类 AbstractList<E>中
- addAll
  
  public boolean addAll(Collection<? extends E> c)
  
  将指定集合中的所有元素按照它们由指定集合的迭代器返回的顺序追加到此列表的末尾。如果在操作进行时修改了指定集合，则此操作的行为是未定义的。（这意味着如果指定的集合是此列表，并且此列表非空，则此调用的行为是未定义的。）
  指定者:
  
  addAll 在接口 Collection<E>中
  
  指定者:
  
  addAll 在接口 List<E>中
  
  覆盖:
  
  addAll 在类 AbstractCollection<E>中
  
  参数:
  
  c - 包含要添加到此列表中的元素的集合
  
  返回值:
  
  如果此列表由于调用而更改，则返回true
  
  抛出:
  
  NullPointerException - 如果指定的集合为null
  
  参见:
  
  AbstractCollection.add(Object)
- addAll
  
  public boolean addAll(int index, Collection<? extends E> c)
  
  将指定集合中的所有元素从指定位置开始插入到此列表中。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。新元素将按照它们由指定集合的迭代器返回的顺序出现在列表中。
  
  指定者:
  
  addAll 在接口 List<E>中
  
  覆盖:
  
  addAll 在类 AbstractList<E>中
  
  参数:
  
  index - 要从指定集合中插入第一个元素的索引
  
  c - 包含要添加到此列表中的元素的集合
  
  返回值:
  
  如果此列表由于调用而更改，则返回true
  
  抛出:
  
  IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index > size()）
  
  NullPointerException - 如果指定的集合为null
- removeRange
  
  protected void removeRange(int fromIndex, int toIndex)
  
  从此列表中删除索引位于fromIndex（包括）和toIndex（不包括）之间的所有元素。将任何后续元素向左移动（减少它们的索引）。此调用通过(toIndex - fromIndex)元素缩短列表。（如果toIndex==fromIndex，则此操作不起作用。）
  
  覆盖:
  
  removeRange 在类 AbstractList<E>中
  
  参数:
  
  fromIndex - 要删除的第一个元素的索引
  
  toIndex - 要删除的最后一个元素之后的索引
  
  抛出:
  
  IndexOutOfBoundsException - 如果fromIndex或toIndex超出范围（fromIndex < 0 || toIndex > size() || toIndex < fromIndex）
- removeAll
  
  public boolean removeAll(Collection<?> c)
  
  从此列表中删除包含在指定集合中的所有元素。
  指定者：
  
  removeAll 在接口 Collection<E>中
  
  指定者：
  
  removeAll 在接口 List<E>中
  
  覆盖：
  
  removeAll 在类 AbstractCollection<E>中
  
  参数：
  
  c - 包含要从此列表中移除的元素的集合
  
  返回值：
  
  true 如果此列表因调用而更改
  
  抛出：
  
  ClassCastException - 如果此列表的元素的类与指定的集合不兼容（可选）
  
  NullPointerException - 如果此列表包含空元素且指定的集合不允许空元素（可选），或者指定的集合为null
  
  参见：
  
  Collection.contains(Object)
- retainAll
  
  public boolean retainAll(Collection<?> c)
  
  仅保留此列表中包含在指定集合中的元素。换句话说，从此列表中删除所有不包含在指定集合中的元素。
  指定者：
  
  retainAll 在接口 Collection<E>中
  
  指定者：
  
  retainAll 在接口 List<E>中
  
  覆盖：
  
  retainAll 在类 AbstractCollection<E>中
  
  参数：
  
  c - 包含要在此列表中保留的元素的集合
  
  返回值：
  
  true 如果此列表因调用而更改
  
  抛出：
  
  ClassCastException - 如果此列表的元素的类与指定的集合不兼容（可选）
  
  NullPointerException - 如果此列表包含空元素且指定的集合不允许空元素（可选），或者指定的集合为null
  
  参见：
  
  Collection.contains(Object)
- listIterator
  
  public ListIterator<E> listIterator(int index)
  
  返回一个列表迭代器，该迭代器按正确顺序遍历此列表中的元素，从列表中的指定位置开始。指定的索引表示通过对 next 的初始调用将返回的第一个元素。对 previous 的初始调用将返回指定索引减一的元素。
  返回的列表迭代器是 fail-fast 的。
  
  指定者：
  
  listIterator 在接口 List<E>中
  
  覆盖：
  
  listIterator 在类 AbstractList<E>中
  
  参数：
  
  index - 要从列表迭代器返回的第一个元素的索引（通过调用 next）
  
  返回值：
  
  返回一个列表迭代器，该迭代器按正确顺序遍历此列表中的元素，从列表中的指定位置开始
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围（index < 0 || index > size()）
- listIterator
  
  public ListIterator<E> listIterator()
  
  返回一个列表迭代器，该迭代器按正确顺序遍历此列表中的元素。
  返回的列表迭代器是 fail-fast 的。
  指定者：
  
  listIterator 在接口 List<E>中
  
  覆盖：
  
  listIterator 在类 AbstractList<E>中
  
  返回值：
  
  返回一个列表迭代器，该迭代器按正确顺序遍历此列表中的元素
  
  参见：
  
  listIterator(int)
- iterator
  
  public Iterator<E> iterator()
  
  返回一个迭代器，该迭代器按正确顺序遍历此列表中的元素。
  返回的迭代器是 fail-fast 的。
  
  指定者：
  
  iterator 在接口 Collection<E>中
  
  指定者：
  
  iterator 在接口 Iterable<E>中
  
  指定者：
  
  iterator 在接口 List<E>中
  
  覆盖：
  
  iterator 在类 AbstractList<E>中
  
  返回值：
  
  返回一个迭代器，该迭代器按正确顺序遍历此列表中的元素
- subList
  
  public List<E> subList(int fromIndex, int toIndex)
  返回此列表中指定的 fromIndex（包括）到 toIndex（不包括）之间的部分视图。（如果 fromIndex 和 toIndex 相等，则返回的列表为空。）返回的列表由此列表支持，因此返回列表中的非结构性更改会反映在此列表中，反之亦然。返回的列表支持所有可选的列表操作。
  此方法消除了对显式范围操作（通常存在于数组中的操作）的需求。任何期望列表的操作都可以通过传递子列表视图而不是整个列表来用作范围操作。例如，以下习语从列表中删除一系列元素：
  
  list.subList(from, to).clear();
  可以为 indexOf(Object) 和 lastIndexOf(Object) 构造类似的习语，并且 Collections 类中的所有算法都可以应用于子列表。
  如果支持列表的源元素被修改，则通过此方法返回的列表的语义将变得不确定（即，此列表被 结构性修改 以外的任何方式修改）。结构性修改是指更改此列表的大小或以某种方式扰乱它，以致正在进行的迭代可能产生不正确的结果。
  指定者：
  
  subList 在接口 List<E>中
  
  覆盖：
  
  subList 在类 AbstractList<E>中
  
  参数：
  
  fromIndex - 子列表的低端点（包括）
  
  toIndex - 子列表的高端点（不包括）
  
  返回值：
  
  返回此列表中指定范围的视图
  
  抛出：
  
  IndexOutOfBoundsException - 如果端点索引值超出范围 (fromIndex < 0 || toIndex > size)
  
  IllegalArgumentException - 如果端点索引顺序不正确 (fromIndex > toIndex)
- forEach
  
  public void forEach(Consumer<? super E> action)
  
  从接口复制的描述： Iterable
  
  对 Iterable 的每个元素执行给定操作，直到所有元素都已处理或操作引发异常。如果指定了迭代顺序，则按照迭代顺序执行操作。操作引发的异常将传递给调用者。
  如果操作执行会修改元素的底层源并产生副作用，则此方法的行为是未指定的，除非覆盖类已指定了并发修改策略。
  
  指定由：
  
  forEach 在接口 Iterable<E>
  
  参数：
  
  action - 每个元素要执行的操作
  
  抛出：
  
  NullPointerException - 如果指定的操作为null
- spliterator
  
  public Spliterator<E> spliterator()
  
  创建一个在此列表中的元素上进行延迟绑定和快速失败的Spliterator。
  Spliterator报告Spliterator.SIZED、Spliterator.SUBSIZED和Spliterator.ORDERED。重写实现应该记录其他特征值的报告。
  
  指定由：
  
  spliterator 在接口 Collection<E>
  
  指定由：
  
  spliterator 在接口 Iterable<E>
  
  指定由：
  
  spliterator 在接口 List<E>
  
  返回：
  
  此列表中的元素的Spliterator
  
  自1.8起
- removeIf
  
  public boolean removeIf(Predicate<? super E> filter)
  
  从接口复制的描述： Collection
  
  删除满足给定谓词的此集合的所有元素。在迭代期间或由谓词引发的错误或运行时异常将被传递给调用者。
  
  指定由：
  
  removeIf 在接口 Collection<E>
  
  参数：
  
  filter - 一个返回true以删除元素的谓词
  
  返回：
  
  如果有任何元素被删除，则为true
  
  抛出：
  
  NullPointerException - 如果指定的过滤器为null

Class ArrayList<E>

Field Summary

Fields declared in class java.util.AbstractList

Constructor Summary

Method Summary

Methods declared in class java.util.AbstractList

Methods declared in class java.util.AbstractCollection

Methods declared in class java.lang.Object

Methods declared in interface java.util.Collection

Methods declared in interface java.util.List

Constructor Details

ArrayList

ArrayList

ArrayList

Method Details

trimToSize

ensureCapacity

size

isEmpty

contains

indexOf

lastIndexOf

clone

toArray

toArray

get

getFirst

getLast

set

add

add

addFirst

addLast

remove

removeFirst

removeLast

equals

hashCode

remove

clear

addAll

addAll

removeRange

removeAll

retainAll

listIterator

listIterator

iterator

subList

forEach

spliterator

removeIf