java.util
类 Vector<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>
          java.util.Vector<E>

所有已实现的接口：

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

直接已知子类：

Stack

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

Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按 capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector 的 elements 方法返回的 Enumeration 不是 快速失败的。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

从 Java 2 平台 v1.2 开始，此类改进为可以实现 List 接口，使它成为 Java Collections Framework 的成员。与新 collection 实现不同，Vector 是同步的。

从以下版本开始：

JDK1.0

另请参见：

Collection, List, ArrayList, LinkedList, 序列化表格

字段摘要

protected int	capacityIncrement 向量的大小大于其容量时，容量自动增加的量。
protected int	elementCount Vector 对象中的有效组件数。
protected Object[]	elementData 存储向量组件的数组缓冲区。

从类 java.util.AbstractList 继承的字段

modCount

构造方法摘要

Vector()
构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。

Vector(Collection<? extends E> c)
构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。

Vector(int initialCapacity)
使用指定的初始容量和等于零的容量增量构造一个空向量。

Vector(int initialCapacity, int capacityIncrement)
使用指定的初始容量和容量增量构造一个空的向量。

方法摘要

boolean	add(E e) 将指定元素添加到此向量的末尾。
void	add(int index, E element) 在此向量的指定位置插入指定的元素。
boolean	addAll(Collection<? extends E> c) 将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。
boolean	addAll(int index, Collection<? extends E> c) 在指定位置将指定 Collection 中的所有元素插入到此向量中。
void	addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。
int	capacity() 返回此向量的当前容量。
void	clear() 从此向量中移除所有元素。
Object	clone() 返回向量的一个副本。
boolean	contains(Object o) 如果此向量包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果此向量包含指定 Collection 中的所有元素，则返回 true。
void	copyInto(Object[] anArray) 将此向量的组件复制到指定的数组中。
E	elementAt(int index) 返回指定索引处的组件。
Enumeration<E>	elements() 返回此向量的组件的枚举。
void	ensureCapacity(int minCapacity) 增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
boolean	equals(Object o) 比较指定对象与此向量的相等性。
E	firstElement() 返回此向量的第一个组件（位于索引 0) 处的项）。
E	get(int index) 返回向量中指定位置的元素。
int	hashCode() 返回此向量的哈希码值。
int	indexOf(Object o) 返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。
int	indexOf(Object o, int index) 返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。
void	insertElementAt(E obj, int index) 将指定对象作为此向量中的组件插入到指定的 index 处。
boolean	isEmpty() 测试此向量是否不包含组件。
E	lastElement() 返回此向量的最后一个组件。
int	lastIndexOf(Object o) 返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。
int	lastIndexOf(Object o, int index) 返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。
E	remove(int index) 移除此向量中指定位置的元素。
boolean	remove(Object o) 移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
boolean	removeAll(Collection<?> c) 从此向量中移除包含在指定 Collection 中的所有元素。
void	removeAllElements() 从此向量中移除全部组件，并将其大小设置为零。
boolean	removeElement(Object obj) 从此向量中移除变量的第一个（索引最小的）匹配项。
void	removeElementAt(int index) 删除指定索引处的组件。
protected void	removeRange(int fromIndex, int toIndex) 从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。
boolean	retainAll(Collection<?> c) 在此向量中仅保留包含在指定 Collection 中的元素。
E	set(int index, E element) 用指定的元素替换此向量中指定位置处的元素。
void	setElementAt(E obj, int index) 将此向量指定 index 处的组件设置为指定的对象。
void	setSize(int newSize) 设置此向量的大小。
int	size() 返回此向量中的组件数。
List<E>	subList(int fromIndex, int toIndex) 返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
Object[]	toArray() 返回一个数组，包含此向量中以恰当顺序存放的所有元素。
<T> T[]	toArray(T[] a) 返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。
String	toString() 返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
void	trimToSize() 对此向量的容量进行微调，使其等于向量的当前大小。

从类 java.util.AbstractList 继承的方法

iterator, listIterator, listIterator

从类 java.lang.Object 继承的方法

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

从接口 java.util.List 继承的方法

iterator, listIterator, listIterator

字段详细信息

elementData

protected Object[] elementData

存储向量组件的数组缓冲区。vector 的容量就是此数据缓冲区的长度，该长度至少要足以包含向量的所有元素。

Vector 中的最后一个元素后的任何数组元素都为 null。

elementCount

protected int elementCount

Vector 对象中的有效组件数。从 elementData[0] 到 elementData[elementCount-1] 的组件均为实际项。

capacityIncrement

protected int capacityIncrement

向量的大小大于其容量时，容量自动增加的量。如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍。

构造方法详细信息

Vector

public Vector(int initialCapacity,
              int capacityIncrement)

使用指定的初始容量和容量增量构造一个空的向量。

参数：

initialCapacity - 向量的初始容量

capacityIncrement - 当向量溢出时容量增加的量

抛出：

IllegalArgumentException - 如果指定的初始容量为负数

Vector

public Vector(int initialCapacity)

使用指定的初始容量和等于零的容量增量构造一个空向量。

参数：

initialCapacity - 向量的初始容量

抛出：

IllegalArgumentException - 如果指定的初始容量为负数

Vector

public Vector()

构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。

Vector

public Vector(Collection<? extends E> c)

构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。

参数：

c - 其元素要放入此向量中的 collection

抛出：

NullPointerException - 如果指定的 collection 为 null

从以下版本开始：

1.2

方法详细信息

copyInto

public void copyInto(Object[] anArray)

将此向量的组件复制到指定的数组中。此向量中索引 k 处的项将复制到 anArray 的组件 k 中。

参数：

anArray - 要将组件复制到其中的数组

抛出：

NullPointerException - 如果给定的数组为 null

IndexOutOfBoundsException - 如果指定数组不够大，不能够保存此向量中的所有组件

ArrayStoreException - 如果此向量的组件不属于可在指定数组中存储的运行时类型

另请参见：

toArray(Object[])

trimToSize

public void trimToSize()

对此向量的容量进行微调，使其等于向量的当前大小。如果此向量的容量大于其当前大小，则通过将其内部数据数组（保存在字段 elementData 中）替换为一个较小的数组，从而将容量更改为等于当前大小。应用程序可以使用此操作最小化向量的存储。

ensureCapacity

public void ensureCapacity(int minCapacity)

增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。

如果此向量的当前容量小于 minCapacity，则通过将其内部数据数组（保存在字段 elementData 中）替换为一个较大的数组来增加其容量。新数据数组的大小将为原来的大小加上 capacityIncrement，除非 capacityIncrement 的值小于等于零，在后一种情况下，新的容量将为原来容量的两倍，不过，如果此大小仍然小于 minCapacity，则新容量将为 minCapacity。

参数：

minCapacity - 需要的最小容量

setSize

public void setSize(int newSize)

设置此向量的大小。如果新大小大于当前大小，则会在向量的末尾添加相应数量的 null 项。如果新大小小于当前大小，则丢弃索引 newSize 处及其之后的所有项。

参数：

newSize - 此向量的新大小

抛出：

ArrayIndexOutOfBoundsException - 如果新大小为负数

capacity

public int capacity()

返回此向量的当前容量。

返回：

当前容量（保存在此向量的 elementData 字段中的内部数据数组的长度）

size

public int size()

返回此向量中的组件数。

指定者：

接口 Collection<E> 中的 size

指定者：

接口 List<E> 中的 size

指定者：

类 AbstractCollection<E> 中的 size

返回：

此向量中的组件数

isEmpty

public boolean isEmpty()

测试此向量是否不包含组件。

指定者：

接口 Collection<E> 中的 isEmpty

指定者：

接口 List<E> 中的 isEmpty

覆盖：

类 AbstractCollection<E> 中的 isEmpty

返回：

当且仅当此向量没有组件（也就是说其大小为零）时返回 true；否则返回 false。

elements

public Enumeration<E> elements()

返回此向量的组件的枚举。返回的 Enumeration 对象将生成此向量中的所有项。生成的第一项为索引 0 处的项，然后是索引 1 处的项，依此类推。

返回：

此向量的组件的枚举

另请参见：

Iterator

contains

public boolean contains(Object o)

如果此向量包含指定的元素，则返回 true。更确切地讲，当且仅当此向量至少包含一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，返回 true。

指定者：

接口 Collection<E> 中的 contains

指定者：

接口 List<E> 中的 contains

覆盖：

类 AbstractCollection<E> 中的 contains

参数：

o - 测试在此向量中是否存在的元素

返回：

如果此向量包含指定的元素，则返回 true

indexOf

public int indexOf(Object o)

返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i；如果没有这样的索引，则返回 -1。

指定者：

接口 List<E> 中的 indexOf

覆盖：

类 AbstractList<E> 中的 indexOf

参数：

o - 要搜索的元素

返回：

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

indexOf

public int indexOf(Object o,
                   int index)

返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。更确切地讲，返回满足 (i >= index && (o==null ? get(i)==null : o.equals(get(i)))) 的最低索引 i；如果没有这样的索引，则返回 -1。

参数：

o - 要搜索的元素

index - 搜索开始处的索引

返回：

此向量中 index 位置或之后位置处第一次出现的指定元素的索引；如果未找到该元素，则返回 -1。

抛出：

IndexOutOfBoundsException - 如果指定索引为负数

另请参见：

Object.equals(Object)

lastIndexOf

public int lastIndexOf(Object o)

返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i；如果没有这样的索引，则返回 -1。

指定者：

接口 List<E> 中的 lastIndexOf

覆盖：

类 AbstractList<E> 中的 lastIndexOf

参数：

o - 要搜索的元素

返回：

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

lastIndexOf

public int lastIndexOf(Object o,
                       int index)

返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。更确切地讲，返回满足 (i <= index && (o==null ? get(i)==null : o.equals(get(i)))) 的最高索引 i；如果没有这样的索引，则返回 -1。

参数：

o - 要搜索的元素

index - 逆向搜索开始处的索引

返回：

此向量中小于等于 index 位置处最后一次出现的指定元素的索引；如果未找到该元素，则返回 -1。

抛出：

IndexOutOfBoundsException - 如果指定索引大于等于此向量的当前大小

elementAt

public E elementAt(int index)

返回指定索引处的组件。

此方法的功能与 get(int) 方法的功能完全相同（后者是 List 接口的一部分）。

参数：

index - 此向量的一个索引

返回：

指定索引处的组件

抛出：

ArrayIndexOutOfBoundsException - 如果该索引超出范围 (index < 0 || index >= size())

firstElement

public E firstElement()

返回此向量的第一个组件（位于索引 0) 处的项）。

返回：

此向量的第一个组件

抛出：

NoSuchElementException - 如果此向量没有组件

lastElement

public E lastElement()

返回此向量的最后一个组件。

返回：

向量的最后一个组件，即索引 size() - 1 处的组件。

抛出：

NoSuchElementException - 如果此向量为空

setElementAt

public void setElementAt(E obj,
                         int index)

将此向量指定 index 处的组件设置为指定的对象。丢弃该位置以前的组件。

索引必须为一个大于等于 0 且小于向量当前大小的值。

此方法的功能与 set(int, E) 方法的功能完全相同（后者是 List 接口的一部分）。注意，set 方法将反转参数的顺序，与数组用法更为匹配。另外还要注意，set 方法将返回以前存储在指定位置的旧值。

参数：

obj - 将用来设置组件的内容

index - 指定的索引

抛出：

ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

removeElementAt

public void removeElementAt(int index)

删除指定索引处的组件。此向量中的每个索引大于等于指定 index 的组件都将下移，使其索引值变成比以前小 1 的值。此向量的大小将减 1。

索引必须为一个大于等于 0 且小于向量当前大小的值。

此方法的功能与 remove(int) 方法的功能完全相同（后者是 List 接口的一部分）。注意，remove 方法将返回存储在指定位置的旧值。

参数：

index - 要移除对象的索引

抛出：

ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

insertElementAt

public void insertElementAt(E obj,
                            int index)

将指定对象作为此向量中的组件插入到指定的 index 处。此向量中的每个索引大于等于指定 index 的组件都将向上移位，使其索引值变成比以前大 1 的值。

索引必须为一个大于等于 0 且小于等于向量当前大小的值（如果索引等于向量的当前大小，则将新元素添加到向量）。

此方法的功能与 add(int, E) 方法的功能完全相同（后者是 List 接口的一部分）。注意，add 方法将反转参数的顺序，与数组用法更为匹配。

参数：

obj - 要插入的组件

index - 新组件的插入位置

抛出：

ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

addElement

public void addElement(E obj)

将指定的组件添加到此向量的末尾，将其大小增加 1。如果向量的大小比容量大，则增大其容量。

此方法的功能与 add(E) 方法的功能完全相同（后者是 List 接口的一部分）。

参数：

obj - 要添加的组件

removeElement

public boolean removeElement(Object obj)

从此向量中移除变量的第一个（索引最小的）匹配项。如果在此向量中找到该对象，那么向量中索引大于等于该对象索引的每个组件都会下移，使其索引值变成比以前小 1 的值。

此方法的功能与 remove(Object) 方法的功能完全相同（后者是 List 接口的一部分）。

参数：

obj - 要移除的组件

返回：

如果变量值是此向量的一个组件，则返回 true；否则返回 false。

removeAllElements

public void removeAllElements()

从此向量中移除全部组件，并将其大小设置为零。

此方法的功能与 clear() 方法的功能完全相同（后者是 List 接口的一部分）。

clone

public Object clone()

返回向量的一个副本。副本中将包含一个对内部数据数组副本的引用，而非对此 Vector 对象的原始内部数据数组的引用。

覆盖：

类 Object 中的 clone

返回：

向量的一个副本

另请参见：

Cloneable

toArray

public Object[] toArray()

返回一个数组，包含此向量中以恰当顺序存放的所有元素。

指定者：

接口 Collection<E> 中的 toArray

指定者：

接口 List<E> 中的 toArray

覆盖：

类 AbstractCollection<E> 中的 toArray

返回：

包含此 collection 中所有元素的数组

从以下版本开始：

1.2

另请参见：

Arrays.asList(Object[])

toArray

public <T> T[] toArray(T[] a)

返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。如果向量能够适应指定的数组，则返回该数组。否则使用此数组的运行时类型和此向量的大小分配一个新数组。

如果向量能够适应指定的数组，而且还有多余空间（即数组的元素比向量的元素多），则将紧跟向量末尾的数组元素设置为 null。（仅 在调用者知道向量不包含任何 null 元素的情况下，这对确定向量的长度才有用）。

指定者：

接口 Collection<E> 中的 toArray

指定者：

接口 List<E> 中的 toArray

覆盖：

类 AbstractCollection<E> 中的 toArray

参数：

a - 要在其中存储向量元素的数组（如果该数组足够大）；否则，将为此分配一个具有相同运行时类型的新数组。

返回：

包含向量元素的数组

抛出：

ArrayStoreException - 如果 a 的运行时类型不是此向量中每个元素的运行时类型的超类型

NullPointerException - 如果给定的数组为 null

从以下版本开始：

1.2

get

public E get(int index)

返回向量中指定位置的元素。

指定者：

接口 List<E> 中的 get

指定者：

类 AbstractList<E> 中的 get

参数：

index - 要返回元素的索引

返回：

指定索引处的对象

抛出：

ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

从以下版本开始：

1.2

set

public E set(int index,
             E element)

用指定的元素替换此向量中指定位置处的元素。

指定者：

接口 List<E> 中的 set

覆盖：

类 AbstractList<E> 中的 set

参数：

index - 要替换元素的索引

element - 要存储在指定位置的元素

返回：

以前位于指定位置处的元素

抛出：

ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

从以下版本开始：

1.2

add

public boolean add(E e)

将指定元素添加到此向量的末尾。

指定者：

接口 Collection<E> 中的 add

指定者：

接口 List<E> 中的 add

覆盖：

类 AbstractList<E> 中的 add

参数：

e - 要添加到此向量的元素

返回：

true（根据 Collection.add(E) 的规定）

从以下版本开始：

1.2

remove

public boolean remove(Object o)

移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。更确切地讲，移除其索引 i 满足 (o==null ? get(i)==null : o.equals(get(i))) 的元素（如果存在这样的元素）。

指定者：

接口 Collection<E> 中的 remove

指定者：

接口 List<E> 中的 remove

覆盖：

类 AbstractCollection<E> 中的 remove

参数：

o - 要从向量中移除的元素（如果存在）

返回：

如果向量包含指定元素，则返回 true

从以下版本开始：

1.2

add

public void add(int index,
                E element)

在此向量的指定位置插入指定的元素。将当前位于该位置的元素（如果有）及所有后续元素右移（将其索引加 1）。

指定者：

接口 List<E> 中的 add

覆盖：

类 AbstractList<E> 中的 add

参数：

index - 要在其位置插入指定元素的索引

element - 要插入的元素

抛出：

ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

从以下版本开始：

1.2

remove

public E remove(int index)

移除此向量中指定位置的元素。将所有后续元素左移（将其索引减 1）。返回此向量中移除的元素。

指定者：

接口 List<E> 中的 remove

覆盖：

类 AbstractList<E> 中的 remove

参数：

index - 要移除元素的索引

返回：

移除的元素

抛出：

ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

从以下版本开始：

1.2

clear

public void clear()

从此向量中移除所有元素。此调用返回后，向量将为空（除非抛出了异常）。

指定者：

接口 Collection<E> 中的 clear

指定者：

接口 List<E> 中的 clear

覆盖：

类 AbstractList<E> 中的 clear

从以下版本开始：

1.2

containsAll

public boolean containsAll(Collection<?> c)

如果此向量包含指定 Collection 中的所有元素，则返回 true。

指定者：

接口 Collection<E> 中的 containsAll

指定者：

接口 List<E> 中的 containsAll

覆盖：

类 AbstractCollection<E> 中的 containsAll

参数：

c - 要在此向量中测试是否包含其元素的 collection

返回：

如果此向量包含指定 collection 中的所有元素，则返回 true

抛出：

NullPointerException - 如果指定 collection 为 null

另请参见：

AbstractCollection.contains(Object)

addAll

public boolean addAll(Collection<? extends E> c)

将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。如果指定的 Collection 在操作过程中被修改，则此操作的行为是不确定的（这意味着如果指定的 Collection 是此向量，而此向量不为空，则此调用的行为是不确定的）。

指定者：

接口 Collection<E> 中的 addAll

指定者：

接口 List<E> 中的 addAll

覆盖：

类 AbstractCollection<E> 中的 addAll

参数：

c - 要插入到此向量的元素

返回：

如果此向量由于调用而更改，则返回 true

抛出：

NullPointerException - 如果指定 collection 为 null

从以下版本开始：

1.2

另请参见：

AbstractCollection.add(Object)

removeAll

public boolean removeAll(Collection<?> c)

从此向量中移除包含在指定 Collection 中的所有元素。

指定者：

接口 Collection<E> 中的 removeAll

指定者：

接口 List<E> 中的 removeAll

覆盖：

类 AbstractCollection<E> 中的 removeAll

参数：

c - 要从向量中移除的元素的 collection

返回：

如果此向量由于调用而更改，则返回 true

抛出：

ClassCastException - 如果此向量中的一个或多个元素的类型与指定 collection 不兼容（可选）

NullPointerException - 如果此向量包含一个或多个 null 元素并且指定 collection 不支持 null 元素（可选），或者指定 collection 为 null

从以下版本开始：

1.2

另请参见：

AbstractCollection.remove(Object), AbstractCollection.contains(Object)

retainAll

public boolean retainAll(Collection<?> c)

在此向量中仅保留包含在指定 Collection 中的元素。换句话说，从此向量中移除所有未包含在指定 Collection 中的元素。

指定者：

接口 Collection<E> 中的 retainAll

指定者：

接口 List<E> 中的 retainAll

覆盖：

类 AbstractCollection<E> 中的 retainAll

参数：

c - 要在此向量中保留的元素的 collection（移除其他所有元素）

返回：

如果此向量由于调用而更改，则返回 true

抛出：

ClassCastException - 如果此向量中的一个或多个元素的类型与指定 collection 不兼容（可选）

NullPointerException - 如果此向量包含一个或多个 null 元素并且指定 collection 不支持 null 元素（可选），或者指定 collection 为 null

从以下版本开始：

1.2

另请参见：

AbstractCollection.remove(Object), AbstractCollection.contains(Object)

addAll

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

在指定位置将指定 Collection 中的所有元素插入到此向量中。将当前位于该位置的元素（如果有）及所有后续元素右移（增大其索引值）。新元素在向量中按照其由指定 collection 的迭代器所返回的顺序出现。

指定者：

接口 List<E> 中的 addAll

覆盖：

类 AbstractList<E> 中的 addAll

参数：

index - 要插入指定 collection 的第一个元素的索引

c - 要插入到此向量的元素

返回：

如果此向量由于调用而更改，则返回 true

抛出：

ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

NullPointerException - 如果指定的 collection 为 null

从以下版本开始：

1.2

equals

public boolean equals(Object o)

比较指定对象与此向量的相等性。当且仅当指定的对象也是一个 List、两个 List 大小相同，并且其中所有对应的元素对都相等 时才返回 true。（如果 (e1==null ? e2==null : e1.equals(e2))，则两个元素 e1 和 e2 相等）。换句话说，如果两个 List 包含相同顺序的相同元素，则这两个 List 就定义为相等。

指定者：

接口 Collection<E> 中的 equals

指定者：

接口 List<E> 中的 equals

覆盖：

类 AbstractList<E> 中的 equals

参数：

o - 要与此向量进行相等性比较的对象

返回：

如果指定的 Object 与此向量相等，则返回 true

另请参见：

Object.hashCode(), Hashtable

hashCode

public int hashCode()

返回此向量的哈希码值。

指定者：

接口 Collection<E> 中的 hashCode

指定者：

接口 List<E> 中的 hashCode

覆盖：

类 AbstractList<E> 中的 hashCode

返回：

此列表的哈希码值

另请参见：

Object.equals(java.lang.Object), Hashtable

toString

public String toString()

返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。

覆盖：

类 AbstractCollection<E> 中的 toString

返回：

此 collection 的字符串表示形式

subList

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

返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。（如果 fromIndex 和 toIndex 相等，则返回的 List 将为空）。返回的 List 由此 List 支持，因此返回 List 中的更改将反映在此 List 中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。

此方法消除了显式范围操作的需要（此操作通常针对数组存在）。通过操作 subList 视图而非整个 List，期望 List 的任何操作可用作范围操作。例如，下面的语句从 List 中移除了元素的范围：

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

可以对 indexOf 和 lastIndexOf 构造类似的语句，而且 Collections 类中的所有算法都可以应用于 subList。

如果通过任何其他方式（而不是通过返回的列表）从结构上修改 内部 List（即此 List），则此方法返回的 List 的语义将变为不确定的（从结构上修改是指更改 List 的大小，或者以其他方式打乱 List，使正在进行的迭代产生错误的结果）。

指定者：

接口 List<E> 中的 subList

覆盖：

类 AbstractList<E> 中的 subList

参数：

fromIndex - subList的低端点（包括）

toIndex - subList 的高端点（不包括）

返回：

List 中指定范围的视图

抛出：

IndexOutOfBoundsException - 如果端点索引值超出范围 (fromIndex < 0 || toIndex > size)

IllegalArgumentException - 如果端点索引顺序错误 (fromIndex > toIndex)

removeRange

protected void removeRange(int fromIndex,
                           int toIndex)

从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。将所有后续元素左移（减小其索引值）。此调用会将 ArrayList 缩小 (toIndex - fromIndex) 个元素（如果 toIndex==fromIndex，则此操作没有任何效果）。

覆盖：

类 AbstractList<E> 中的 removeRange

参数：

fromIndex - 要移除的第一个元素的索引

toIndex - 要移除的最后一个元素之后的索引