java.util
类 Vector

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, 序列化表格

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

返回一个数组，包含此向量中以恰当顺序存放