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 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

从 Java 2 平台 v1.2 开始，已改进此类以实现 List，这样它就成为了 Java 的集合框架的一部分。与新集合的实现不同，Vector 是同步的。

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

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

此类是 Java Collections Framework 的成员。

从以下版本开始：

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)
构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素的顺序排列。

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

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

方法摘要

boolean	add(E o) 将指定元素追加到此向量的末尾。
void	add(int index, E element) 在此向量的指定位置插入指定的元素。
boolean	addAll(Collection<? extends E> c) 将指定 Collection 中的所有元素追加到此向量的末尾，按照指定集合的迭代器所返回的顺序追加这些元素。
boolean	addAll(int index, Collection<? extends E> c) 在指定位置将指定 Collection 中的所有元素插入到此向量中。
void	addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。
int	capacity() 返回此向量的当前容量。
void	clear() 从此向量中移除所有元素。
Object	clone() 返回向量的一个副本。
boolean	contains(Object elem) 测试指定的对象是否为此向量中的组件。
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 elem) 搜索给定参数的第一个匹配项，使用 equals 方法测试相等性。
int	indexOf(Object elem, int index) 搜索给定参数的第一个匹配项，从 index 处开始搜索，并使用 equals 方法测试其相等性。
void	insertElementAt(E obj, int index) 将指定对象作为此向量中的组件插入到指定的 index 处。
boolean	isEmpty() 测试此向量是否不包含组件。
E	lastElement() 返回此向量的最后一个组件。
int	lastIndexOf(Object elem) 返回指定的对象在此向量中最后一个匹配项的索引。
int	lastIndexOf(Object elem, int index) 向后搜索指定的对象，从指定的索引处开始搜索，并返回一个索引。
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)

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

参数：

c - 其元素要放入此向量中的集合。

抛出：

NullPointerException - 如果指定的集合为 null。

从以下版本开始：

1.2

方法详细信息

copyInto

public void copyInto(Object[] anArray)

将此向量的组件复制到指定的数组中。此向量中索引 k 处的项将复制到 anArray 的组件 k 中。数组必须足够大，能够保存此向量中的所有对象，否则抛出 IndexOutOfBoundsException。

参数：

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

抛出：

NullPointerException - 如果给定的数组为 null。

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 处的项，依此类推。

返回：

此向量的组件的枚举。

另请参见：

Enumeration, Iterator

contains

public boolean contains(Object elem)

测试指定的对象是否为此向量中的组件。

指定者：

接口 Collection<E> 中的 contains

指定者：

接口 List<E> 中的 contains

覆盖：

类 AbstractCollection<E> 中的 contains

参数：

elem - 一个对象。

返回：

当且仅当指定的对象与此向量中的某个组件相同时（由 equals 方法确定）返回 true；否则返回 false。

indexOf

public int indexOf(Object elem)

搜索给定参数的第一个匹配项，使用 equals 方法测试相等性。

指定者：

接口 List<E> 中的 indexOf

覆盖：

类 AbstractList<E> 中的 indexOf

参数：

elem - 一个对象。

返回：

返回参数在此向量中的第一个匹配项的索引，也就是使elem.equals(elementData[k]) 为 true 的最小值 k；如果未找到该对象，则返回 -1。

另请参见：

Object.equals(Object)

indexOf

public int indexOf(Object elem,
                   int index)

搜索给定参数的第一个匹配项，从 index 处开始搜索，并使用 equals 方法测试其相等性。

参数：

elem - 一个对象。

index - 非负索引，从此处开始搜索。

返回：

返回对象参数在此向量中 index 位置或之后位置的第一个匹配项的索引，也就是 elem.equals(elementData[k]) && (k >= index) 为 true 的最小值 k；如果未找到该对象，则返回 -1（如果 index 大于等于此 Vector 的当前大小，则返回 -1）。

抛出：

IndexOutOfBoundsException - 如果 index 为负数。

另请参见：

Object.equals(Object)

lastIndexOf

public int lastIndexOf(Object elem)

返回指定的对象在此向量中最后一个匹配项的索引。

指定者：

接口 List<E> 中的 lastIndexOf

覆盖：

类 AbstractList<E> 中的 lastIndexOf

参数：

elem - 需要的组件。

返回：

返回指定对象在此向量中的最后一个匹配项的索引，也就是使 elem.equals(elementData[k]) 为 true 的最大值 k；如果未找到该对象，则返回 -1。

lastIndexOf

public int lastIndexOf(Object elem,
                       int index)

向后搜索指定的对象，从指定的索引处开始搜索，并返回一个索引。

参数：

elem - 需要的组件。

index - 索引，从此处开始搜索。

返回：

返回指定对象在此向量中 index 位置或之前位置的最后一个匹配项的索引，也就是使elem.equals(elementData[k]) && (k >= index) 为 true 的最大值 k；如果未找到该对象，则返回 -1（如果 index 为负数，则返回 -1）。

抛出：

IndexOutOfBoundsException - 如果 index 大于或等于此向量的当前大小。

elementAt

public E elementAt(int index)

返回指定索引处的组件。

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

参数：

index - 此向量的一个索引。

返回：

指定索引处的组件。

抛出：

ArrayIndexOutOfBoundsException - 如果 index 为负数或小于此给定 Vector 对象的当前大小。

另请参见：

get(int), List

firstElement

public E firstElement()

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

返回：

此向量的第一个组件。

抛出：

NoSuchElementException - 如果此向量没有组件。

lastElement

public E lastElement()

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

返回：

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

抛出：

NoSuchElementException - 如果此向量为空。

setElementAt

public void setElementAt(E obj,
                         int index)

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

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

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

参数：

obj - 组件将要设置为的内容。

index - 指定的索引。

抛出：

ArrayIndexOutOfBoundsException - 如果索引无效。

另请参见：

size(), List, set(int, java.lang.Object)

removeElementAt

public void removeElementAt(int index)

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

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

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

参数：

index - 要移除对象的索引。

抛出：

ArrayIndexOutOfBoundsException - 如果索引无效。

另请参见：

size(), remove(int), List

insertElementAt

public void insertElementAt(E obj,
                            int index)

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

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

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

参数：

obj - 要插入的组件。

index - 新组件的插入位置。

抛出：

ArrayIndexOutOfBoundsException - 如果索引无效。

另请参见：

size(), add(int, Object), List

addElement

public void addElement(E obj)

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

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

参数：

obj - 要添加的组件。

另请参见：

add(Object), List

removeElement

public boolean removeElement(Object obj)

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

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

参数：

obj - 要移除的组件。

返回：

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

另请参见：

List.remove(Object), List

removeAllElements

public void removeAllElements()

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

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

另请参见：

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 - 运行时类型不是此向量中每个元素的运行时类型的超类型。

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 o)

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

指定者：

接口 Collection<E> 中的 add

指定者：

接口 List<E> 中的 add

覆盖：

类 AbstractList<E> 中的 add

参数：

o - 要追加到此向量的元素。

返回：

true（按照 Collection.add 的常规协定）。

从以下版本开始：

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<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。

抛出：

NullPointerException - 如果指定的 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。

抛出：

NullPointerException - 如果指定的集合为 null。

从以下版本开始：

1.2

另请参见：

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

addAll

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

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

指定者：

接口 List<E> 中的 addAll

覆盖：

类 AbstractList<E> 中的 addAll

参数：

index - 要插入指定集合的第一个元素的索引。

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 - 要移除的最后一个元素之后的索引。