Most visited

Recently visited

Results for

Added in API level 1

ArrayList

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

java.lang.Object
↳	java.util.AbstractCollection<E>
	↳	java.util.AbstractList<E>
		↳	java.util.ArrayList<E>

Known Direct Subclasses

ObservableArrayList<T>

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

该size，isEmpty，get，set，iterator，并listIterator操作在固定时间内运行。 add操作以分摊的恒定时间运行，即添加n个元素需要O（n）个时间。所有其他操作都在线性时间内运行（粗略地说）。与LinkedList实现相比，常数因子较低。

每个ArrayList实例都有一个容量。容量是用于存储列表中元素的数组大小。它总是至少与列表大小一样大。随着元素被添加到ArrayList，其容量会自动增长。增长政策的细节并未超出添加元素具有不变摊销时间成本的事实。

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

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

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

The iterators returned by this class's iterator和listIterator方法是快速失败的 ：如果在迭代器创建后的任何时候在结构上修改列表，除了通过迭代器自己的remove或add方法之外，迭代器将抛出ConcurrentModificationException 。因此，面对并发修改，迭代器快速而干净地失败，而不是在将来某个未确定的时间冒着任意的，非确定性的行为风险。

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

本课是 Java Collections Framework的成员。

也可以看看：

Summary

Inherited fields

From class java.util.AbstractList

Public constructors
`ArrayList(int initialCapacity)` 用指定的初始容量构造一个空列表。
`ArrayList()` 构造一个初始容量为10的空列表。
`ArrayList(Collection<? extends E> c)` 按照集合迭代器返回的顺序构造一个包含指定集合元素的列表。

Public methods
`boolean`	`add(E e)` 将指定的元素附加到此列表的末尾。
`void`	`add(int index, E element)` 将指定的元素插入此列表中的指定位置。
`boolean`	`addAll(Collection<? extends E> c)` 按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此列表的末尾。
`boolean`	`addAll(int index, Collection<? extends E> c)` 将指定集合中的所有元素插入此列表，从指定的位置开始。
`void`	`clear()` 从列表中删除所有元素。
`Object`	`clone()` 返回此 `ArrayList`实例的浅表副本。
`boolean`	`contains(Object o)` 如果此列表包含指定的元素，则返回 `true` 。
`void`	`ensureCapacity(int minCapacity)` 如有必要，增加此 `ArrayList`实例的容量，以确保它至少能容纳由最小容量参数指定的元素数量。
`void`	`forEach(Consumer<? super E> action)`
`E`	`get(int index)` 返回此列表中指定位置的元素。
`int`	`indexOf(Object o)` 返回此列表中指定元素第一次出现的索引，如果此列表不包含元素，则返回-1。
`boolean`	`isEmpty()` 如果此列表不包含任何元素，则返回 `true` 。
`Iterator<E>`	`iterator()` 以适当的顺序返回此列表中元素的迭代器。
`int`	`lastIndexOf(Object o)` 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
`ListIterator<E>`	`listIterator(int index)` 从列表中的指定位置开始，返回此列表中元素的列表迭代器（以正确的顺序）。
`ListIterator<E>`	`listIterator()` 返回此列表中元素的列表迭代器（按适当顺序）。
`E`	`remove(int index)` 删除此列表中指定位置的元素。
`boolean`	`remove(Object o)` 如果存在，则从该列表中删除指定元素的第一次出现。
`boolean`	`removeAll(Collection<?> c)` 从此列表中删除指定集合中包含的所有元素。
`boolean`	`removeIf(Predicate<? super E> filter)` 删除此集合中满足给定谓词的所有元素。
`void`	`replaceAll(UnaryOperator<E> operator)` 用将运算符应用于该元素的结果替换此列表中的每个元素。
`boolean`	`retainAll(Collection<?> c)` 只保留包含在指定集合中的列表中的元素。
`E`	`set(int index, E element)` 用指定的元素替换此列表中指定位置的元素。
`int`	`size()` 返回此列表中元素的数量。
`void`	`sort(Comparator<? super E> c)` 使用提供的 `Comparator`对此列表进行排序以比较元素。
`Spliterator<E>`	`spliterator()` 通过此列表中的元素创建 late-binding和快速故障 `Spliterator` 。
`List<E>`	`subList(int fromIndex, int toIndex)` 返回指定的 `fromIndex` （含）和 `toIndex`之间的此列表部分的视图，排他。
`Object[]`	`toArray()` 以适当的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）。
`<T> T[]`	`toArray(T[] a)` 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。
`void`	`trimToSize()` 将此 `ArrayList`实例的容量 `修剪`为列表的当前大小。

Protected methods
`void`	`removeRange(int fromIndex, int toIndex)` 从列表中删除索引在 `fromIndex` （含）和 `toIndex`之间的所有元素，排他性。

Inherited methods

From class java.util.AbstractList

`void`	`add(int index, E element)` 将指定元素插入此列表中的指定位置（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`boolean`	`add(E e)` 将指定的元素附加到此列表的末尾（可选操作）。
`boolean`	`addAll(int index, Collection<? extends E> c)` 将指定集合中的所有元素插入指定位置的此列表中（可选操作）。该实现获取指定集合上的迭代器并对其进行迭代，并使用 `add(int, E)`将迭代器中获取的元素一次一个地插入到此列表中适当的位置。
`void`	`clear()` 从此列表中删除所有元素（可选操作）。
`boolean`	`equals(Object o)` 将指定的对象与此列表进行比较以获得相等性。
`abstract E`	`get(int index)` 返回此列表中指定位置的元素。
`int`	`hashCode()` 返回此列表的哈希码值。
`int`	`indexOf(Object o)` 返回此列表中指定元素第一次出现的索引，如果此列表不包含元素，则返回-1。这个实现首先得到一个列表迭代器（与 `listIterator()` ）。
`Iterator<E>`	`iterator()` 以适当的顺序返回此列表中元素的迭代器。
`int`	`lastIndexOf(Object o)` 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。这个实现首先得到一个列表迭代器，指向列表的末尾（用 `listIterator(size())` ）。
`ListIterator<E>`	`listIterator(int index)` 从列表中的指定位置开始，返回此列表中元素的列表迭代器（以正确的顺序）。该实现返回 `ListIterator`接口的直接实现，该接口扩展了 `iterator()`方法返回的 `Iterator`接口的实现。
`ListIterator<E>`	`listIterator()` 返回此列表中元素的列表迭代器（按适当顺序）。该实现返回 `listIterator(0)` 。
`E`	`remove(int index)` 删除此列表中指定位置的元素（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`void`	`removeRange(int fromIndex, int toIndex)` 从列表中删除索引在 `fromIndex` （含）和 `toIndex`之间的所有元素，排他性。
`E`	`set(int index, E element)` 用指定的元素替换此列表中指定位置的元素（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`List<E>`	`subList(int fromIndex, int toIndex)` 返回指定的 `fromIndex` （含）和 `toIndex`之间的此列表部分视图，不包括。该实现返回一个子类为 `AbstractList`的列表。

From class java.util.AbstractCollection

`boolean`	`add(E e)` 确保此集合包含指定的元素（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`boolean`	`addAll(Collection<? extends E> c)` 将指定集合中的所有元素添加到此集合（可选操作）。该实现迭代指定的集合，并将迭代器返回的每个对象依次添加到该集合中。
`void`	`clear()` 从该集合中删除所有元素（可选操作）。此实现迭代该集合，使用 `Iterator.remove`操作删除每个元素。
`boolean`	`contains(Object o)` 如果此集合包含指定的元素，则返回 `true` 。该实现迭代集合中的元素，依次检查每个元素是否与指定元素相等。
`boolean`	`containsAll(Collection<?> c)` 如果此集合包含指定集合中的所有元素，则返回 `true` 。此实现迭代指定的集合，依次检查迭代器返回的每个元素，以查看它是否包含在此集合中。
`boolean`	`isEmpty()` 如果此集合不包含元素，则返回 `true` 。该实现返回 `size() == 0` 。
`abstract Iterator<E>`	`iterator()` 返回此集合中包含的元素的迭代器。
`boolean`	`remove(Object o)` 从该集合中移除指定元素的单个实例（如果存在）（可选操作）。该实现迭代查找指定元素的集合。
`boolean`	`removeAll(Collection<?> c)` 删除指定集合中包含的所有此集合的元素（可选操作）。该实现迭代该集合，依次检查迭代器返回的每个元素，以查看它是否包含在指定集合中。
`boolean`	`retainAll(Collection<?> c)` 仅保留包含在指定集合中的此集合中的元素（可选操作）。该实现迭代该集合，依次检查迭代器返回的每个元素，以查看它是否包含在指定集合中。
`abstract int`	`size()` 返回此集合中的元素数量。
`<T> T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。该实现返回一个数组，其中包含由该集合迭代器以相同顺序返回的所有元素，并存储在数组的连续元素中，从索引 `0`开始。
`Object[]`	`toArray()` 返回包含此集合中所有元素的数组。该实现以索引 `0`开始，以相同的顺序返回一个数组，其中包含由该集合迭代器返回的所有元素，该索引以索引 `0`开头，并存储在数组的连续元素中。
`String`	`toString()` 返回此集合的字符串表示形式。

From class java.lang.Object

From interface java.util.List

`abstract boolean`	`add(E e)` 将指定的元素附加到此列表的末尾（可选操作）。
`abstract void`	`add(int index, E element)` 将指定元素插入此列表中的指定位置（可选操作）。
`abstract boolean`	`addAll(Collection<? extends E> c)` 按指定集合的迭代器（可选操作）返回的顺序，将指定集合中的所有元素追加到此列表的末尾。
`abstract boolean`	`addAll(int index, Collection<? extends E> c)` 将指定集合中的所有元素插入指定位置的此列表中（可选操作）。
`abstract void`	`clear()` 从此列表中删除所有元素（可选操作）。
`abstract boolean`	`contains(Object o)` 如果此列表包含指定的元素，则返回 `true` 。
`abstract boolean`	`containsAll(Collection<?> c)` 如果此列表包含指定集合的所有元素，则返回 `true` 。
`abstract boolean`	`equals(Object o)` 将指定的对象与此列表进行比较以获得相等性。
`abstract E`	`get(int index)` 返回此列表中指定位置的元素。
`abstract int`	`hashCode()` 返回此列表的哈希码值。
`abstract int`	`indexOf(Object o)` 返回此列表中指定元素第一次出现的索引，如果此列表不包含元素，则返回-1。
`abstract boolean`	`isEmpty()` 如果此列表不包含任何元素，则返回 `true` 。
`abstract Iterator<E>`	`iterator()` 以适当的顺序返回此列表中元素的迭代器。
`abstract int`	`lastIndexOf(Object o)` 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
`abstract ListIterator<E>`	`listIterator(int index)` 从列表中的指定位置开始，返回此列表中元素的列表迭代器（以正确的顺序）。
`abstract ListIterator<E>`	`listIterator()` 返回此列表中元素的列表迭代器（按适当顺序）。
`abstract E`	`remove(int index)` 删除此列表中指定位置的元素（可选操作）。
`abstract boolean`	`remove(Object o)` 从列表中删除第一次出现的指定元素（如果存在）（可选操作）。
`abstract boolean`	`removeAll(Collection<?> c)` 从此列表中删除指定集合中包含的所有元素（可选操作）。
`default void`	`replaceAll(UnaryOperator<E> operator)` 用将运算符应用于该元素的结果替换此列表中的每个元素。
`abstract boolean`	`retainAll(Collection<?> c)` 仅保留指定集合中包含的此列表中的元素（可选操作）。
`abstract E`	`set(int index, E element)` 用指定的元素替换此列表中指定位置的元素（可选操作）。
`abstract int`	`size()` 返回此列表中元素的数量。
`default void`	`sort(Comparator<? super E> c)` 使用提供的 `Comparator`对此列表进行排序以比较元素。
`default Spliterator<E>`	`spliterator()` 在此列表中的元素上创建一个 `Spliterator` 。
`abstract List<E>`	`subList(int fromIndex, int toIndex)` 返回指定的 `fromIndex` （含）和 `toIndex`之间的此列表部分的视图，排他。
`abstract Object[]`	`toArray()` 以适当的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）。
`abstract <T> T[]`	`toArray(T[] a)` 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。

From interface java.util.Collection

`abstract boolean`	`add(E e)` 确保此集合包含指定的元素（可选操作）。
`abstract boolean`	`addAll(Collection<? extends E> c)` 将指定集合中的所有元素添加到此集合（可选操作）。
`abstract void`	`clear()` 从该集合中删除所有元素（可选操作）。
`abstract boolean`	`contains(Object o)` 如果此集合包含指定的元素，则返回 `true` 。
`abstract boolean`	`containsAll(Collection<?> c)` 如果此集合包含指定集合中的所有元素，则返回 `true` 。
`abstract boolean`	`equals(Object o)` 将指定的对象与此集合进行比较以获得相等性。
`abstract int`	`hashCode()` 返回此集合的哈希码值。
`abstract boolean`	`isEmpty()` 如果此集合不包含任何元素，则返回 `true` 。
`abstract Iterator<E>`	`iterator()` 返回此集合中元素的迭代器。
`default Stream<E>`	`parallelStream()` 以此集合作为源返回可能并行的 `Stream` 。
`abstract boolean`	`remove(Object o)` 从该集合中移除指定元素的单个实例（如果存在）（可选操作）。
`abstract boolean`	`removeAll(Collection<?> c)` 删除指定集合中包含的所有此集合的元素（可选操作）。
`default boolean`	`removeIf(Predicate<? super E> filter)` 删除此集合中满足给定谓词的所有元素。
`abstract boolean`	`retainAll(Collection<?> c)` 仅保留包含在指定集合中的此集合中的元素（可选操作）。
`abstract int`	`size()` 返回此集合中的元素数量。
`default Spliterator<E>`	`spliterator()` 在此集合中的元素上创建一个 `Spliterator` 。
`default Stream<E>`	`stream()` 以此集合作为源返回一个连续的 `Stream` 。
`abstract <T> T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。
`abstract Object[]`	`toArray()` 返回包含此集合中所有元素的数组。

From interface java.lang.Iterable

Public constructors

ArrayList

Added in API level 1

ArrayList (int initialCapacity)

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

Parameters
`initialCapacity`	`int`: the initial capacity of the list

Throws
`IllegalArgumentException`	if the specified initial capacity is negative

ArrayList

Added in API level 1

ArrayList ()

构造一个初始容量为10的空列表。

ArrayList

Added in API level 1

ArrayList (Collection<? extends E> c)

按照集合迭代器返回的顺序构造一个包含指定集合元素的列表。

Parameters
`c`	`Collection`: the collection whose elements are to be placed into this list

Throws
`NullPointerException`	if the specified collection is null

Public methods

add

Added in API level 1

boolean add (E e)

将指定的元素附加到此列表的末尾。

Parameters
`e`	`E`: element to be appended to this list

Returns
`boolean`	`true` (as specified by `add(E)`)

add

Added in API level 1

void add (int index, 
                E element)

将指定的元素插入此列表中的指定位置。将当前位置的元素（如果有的话）和任何后续元素移到右侧（将其中的一个添加到它们的索引）。

Parameters
`index`	`int`: index at which the specified element is to be inserted
`element`	`E`: element to be inserted

Throws
`IndexOutOfBoundsException`

addAll

Added in API level 1

boolean addAll (Collection<? extends E> c)

按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此列表的末尾。如果在操作过程中修改了指定的集合，则此操作的行为未定义。（这意味着如果指定的集合是这个列表，这个调用的行为是未定义的，并且这个列表是非空的。）

Parameters
`c`	`Collection`: collection containing elements to be added to this list

Returns
`boolean`	`true` if this list changed as a result of the call

Throws
`NullPointerException`	if the specified collection is null

addAll

Added in API level 1

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

将指定集合中的所有元素插入此列表，从指定的位置开始。将当前在该位置的元素（如果有的话）和随后的元素移到右侧（增加它们的索引）。新元素将按照它们由指定集合的迭代器返回的顺序出现在列表中。

Parameters
`index`	`int`: index at which to insert the first element from the specified collection
`c`	`Collection`: collection containing elements to be added to this list

Returns
`boolean`	`true` if this list changed as a result of the call

Throws
`IndexOutOfBoundsException`
`NullPointerException`	if the specified collection is null

clear

Added in API level 1

void clear ()

从列表中删除所有元素。此通话返回后，该列表将为空。

clone

Added in API level 1

Object clone ()

返回此ArrayList实例的浅表副本。（元素本身不被复制。）

Returns
`Object`	a clone of this `ArrayList` instance

contains

Added in API level 1

boolean contains (Object o)

如果此列表包含指定的元素，则返回true 。更正式地，返回true当且仅当该列表包含至少一个元素e，例如(o==null ? e==null : o.equals(e)) 。

Parameters
`o`	`Object`: element whose presence in this list is to be tested

Returns
`boolean`	`true` if this list contains the specified element

ensureCapacity

Added in API level 1

void ensureCapacity (int minCapacity)

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

Parameters
`minCapacity`	`int`: the desired minimum capacity

forEach

Added in API level 24

void forEach (Consumer<? super E> action)

Parameters
`action`	`Consumer`

get

Added in API level 1

E get (int index)

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

Parameters
`index`	`int`: index of the element to return

Returns
`E`	the element at the specified position in this list

Throws
`IndexOutOfBoundsException`

indexOf

Added in API level 1

int indexOf (Object o)

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

Parameters
`o`	`Object`: element to search for

Returns
`int`	the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element

isEmpty

Added in API level 1

boolean isEmpty ()

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

Returns
`boolean`	`true` if this list contains no elements

iterator

Added in API level 1

Iterator<E> iterator ()

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

返回的迭代器是 fail-fast 。

Returns
`Iterator<E>`	an iterator over the elements in this list in proper sequence

lastIndexOf

Added in API level 1

int lastIndexOf (Object o)

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

Parameters
`o`	`Object`: element to search for

Returns
`int`	the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element

listIterator

Added in API level 1

ListIterator<E> listIterator (int index)

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

返回的列表迭代器是 fail-fast 。

Parameters
`index`	`int`: index of the first element to be returned from the list iterator (by a call to `next`)

Returns
`ListIterator<E>`	a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list

Throws
`IndexOutOfBoundsException`

listIterator

Added in API level 1

ListIterator<E> listIterator ()

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

返回的列表迭代器是 fail-fast 。

Returns
`ListIterator<E>`	a list iterator over the elements in this list (in proper sequence)

也可以看看：

listIterator(int)

remove

Added in API level 1

E remove (int index)

删除此列表中指定位置的元素。将任何随后的元素向左移（从其索引中减去一个元素）。

Parameters
`index`	`int`: the index of the element to be removed

Returns
`E`	the element that was removed from the list

Throws
`IndexOutOfBoundsException`

remove

Added in API level 1

boolean remove (Object o)

如果存在，则从该列表中删除指定元素的第一次出现。如果该列表不包含该元素，则不变。更正式地说，删除索引最低的元素i ，使得(o==null ? get(i)==null : o.equals(get(i))) （如果存在这样的元素）。如果此列表包含指定的元素（或者等价地，如果此列表因呼叫而改变），则返回true 。

Parameters
`o`	`Object`: element to be removed from this list, if present

Returns
`boolean`	`true` if this list contained the specified element

removeAll

Added in API level 1

boolean removeAll (Collection<?> c)

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

Parameters
`c`	`Collection`: collection containing elements to be removed from this list

Returns
`boolean`	`true` if this list changed as a result of the call

Throws
`ClassCastException`	if the class of an element of this list is incompatible with the specified collection (optional)
`NullPointerException`	if this list contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null

也可以看看：

contains(Object)

removeIf

Added in API level 24

boolean removeIf (Predicate<? super E> filter)

删除此集合中满足给定谓词的所有元素。在迭代过程中或由谓词抛出的错误或运行时异常会传递给调用者。

Parameters
`filter`	`Predicate`: a predicate which returns `true` for elements to be removed

Returns
`boolean`	`true` if any elements were removed

replaceAll

Added in API level 24

void replaceAll (UnaryOperator<E> operator)

用将运算符应用于该元素的结果替换此列表中的每个元素。由操作员抛出的错误或运行时异常会传递给调用者。

Parameters
`operator`	`UnaryOperator`: the operator to apply to each element

retainAll

Added in API level 1

boolean retainAll (Collection<?> c)

只保留包含在指定集合中的列表中的元素。换句话说，从该列表中删除所有未包含在指定集合中的元素。

Parameters
`c`	`Collection`: collection containing elements to be retained in this list

Returns
`boolean`	`true` if this list changed as a result of the call

Throws
`ClassCastException`	if the class of an element of this list is incompatible with the specified collection (optional)
`NullPointerException`	if this list contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null

也可以看看：

contains(Object)

set

Added in API level 1

E set (int index, 
                E element)

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

Parameters
`index`	`int`: index of the element to replace
`element`	`E`: element to be stored at the specified position

Returns
`E`	the element previously at the specified position

Throws
`IndexOutOfBoundsException`

size

Added in API level 1

int size ()

返回此列表中元素的数量。

Returns
`int`	the number of elements in this list

sort

Added in API level 24

void sort (Comparator<? super E> c)

使用提供的 Comparator对此列表进行排序以比较元素。

Parameters
`c`	`Comparator`: the `Comparator` used to compare list elements. A `null` value indicates that the elements' natural ordering should be used

spliterator

Added in API level 24

Spliterator<E> spliterator ()

在此列表中的元素上创建 late-binding和 快速故障 Spliterator 。

该Spliterator报告SIZED ， SUBSIZED ，并ORDERED 。重写实现应记录附加特征值的报告。

Returns
`Spliterator<E>`	a `Spliterator` over the elements in this list

subList

Added in API level 1

List<E> subList (int fromIndex, 
                int toIndex)

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

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

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

Similar idioms may be constructed for indexOf(Object) and lastIndexOf(Object), and all of the algorithms in the Collections class can be applied to a subList.

如果支持列表（即此列表）在结构上以非返回列表的方式进行了修改，则此方法返回的列表的语义变得未定义。（结构修改是那些改变这个列表的大小，或者以这样一种方式干扰它，以致正在进行的迭代可能产生不正确的结果。）

Parameters
`fromIndex`	`int`: low endpoint (inclusive) of the subList
`toIndex`	`int`: high endpoint (exclusive) of the subList

Returns
`List<E>`	a view of the specified range within this list

Throws
`IndexOutOfBoundsException`
`IllegalArgumentException`

toArray

Added in API level 1

Object[] toArray ()

以适当的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）。

返回的数组将是“安全的”，因为此列表不会保留对它的引用。（换句话说，这个方法必须分配一个新的数组）。调用者可以自由修改返回的数组。

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

Returns
`Object[]`	an array containing all of the elements in this list in proper sequence

toArray

Added in API level 1

T[] toArray (T[] a)

以正确的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。如果列表符合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此列表的大小分配一个新数组。

如果列表符合指定数组并且有空余空间（即数组的元素多于列表），则紧跟在集合结束后的数组中的元素设置为null 。（仅当调用者知道列表不包含任何空元素时，这对确定列表的长度很有用。）

Parameters
`a`	`T`: the array into which the elements of the list are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.

Returns
`T[]`	an array containing the elements of the list

Throws
`ArrayStoreException`	if the runtime type of the specified array is not a supertype of the runtime type of every element in this list
`NullPointerException`	if the specified array is null

trimToSize

Added in API level 1

void trimToSize ()

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

Protected methods

removeRange

Added in API level 1

void removeRange (int fromIndex, 
                int toIndex)

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

Parameters
`fromIndex`	`int`: index of first element to be removed
`toIndex`	`int`: index after last element to be removed

Throws
`IndexOutOfBoundsException`	if `fromIndex` or `toIndex` is out of range (`fromIndex < 0 \|\| fromIndex >= size() \|\| toIndex > size() \|\| toIndex < fromIndex`)