java.lang.Object

java.util.Vector<E>

类型参数：: 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 大小的块的形式增加。应用程序可以在插入大量组件之前增加向量的容量；这减少了增量重新分配的数量。

此类的 iterator 和 listIterator 方法返回的迭代器是 fail-fast ：如果在创建迭代器后的任何时间以任何方式对向量进行结构修改，除了通过迭代器自己的 remove 或 add 方法，迭代器将抛出 ConcurrentModificationException 。因此，面对并发修改，迭代器会快速干净地失败，而不是冒着在未来不确定的时间出现任意的、不确定的行为的风险。 elements 方法返回的Enumerations 是notfail-fast；如果在创建枚举后的任何时候对 Vector 进行了结构修改，则枚举的结果是未定义的。

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

从 Java 2 平台 v1.2 开始，这个类被改造以实现 List 接口，使其成为 Java 集合框架的成员。与新的集合实现不同，Vector 是同步的。如果不需要线程安全实现，建议使用 ArrayList 代替 Vector。

自从：

1.0

参见：

字段摘要

字段

修饰符和类型

Field

描述

protected int

capacityIncrement

当向量的大小大于其容量时，向量的容量自动增加的量。

protected int

elementCount

此 Vector 对象中的有效组件数。

protected Object[]

elementData

存储向量组件的数组缓冲区。

在类 java.util.AbstractList 中声明的字段
modCount
构造方法总结

构造方法

构造方法

描述

Vector()

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

Vector(int initialCapacity)

构造一个具有指定初始容量且容量增量为零的空向量。

Vector(int initialCapacity, int capacityIncrement)

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

Vector(Collection<? extends E> c)

构造一个包含指定集合元素的向量，按照集合迭代器返回元素的顺序。
方法总结

修饰符和类型

方法

描述

void

add(int index, E element)

在此 Vector 中的指定位置插入指定元素。

boolean

add(E e)

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

boolean

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

将指定 Collection 中的所有元素插入此 Vector 的指定位置。

boolean

addAll(Collection<? extends E> c)

将指定 Collection 中的所有元素附加到此 Vector 的末尾，按照它们由指定 Collection 的 Iterator 返回的顺序。

void

addElement(E obj)

将指定的组件添加到此向量的末尾，将其大小增加一。

int

capacity()

返回此向量的当前容量。

void

clear()

从此 Vector 中移除所有元素。

Object

clone()

返回此向量的克隆。

boolean

contains(Object o)

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

boolean

containsAll(Collection<?> c)

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

void

copyInto(Object[] anArray)

将此向量的组件复制到指定的数组中。

E

elementAt(int index)

返回指定索引处的组件。

Enumeration<E>

elements()

返回此向量的组件的枚举。

void

ensureCapacity(int minCapacity)

如有必要，增加此向量的容量，以确保它至少可以容纳最小容量参数指定的组件数。

boolean

equals(Object o)

比较指定的 Object 与此 Vector 是否相等。

E

firstElement()

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

void

forEach(Consumer<? super E> action)

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

E

get(int index)

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

int

hashCode()

返回此 Vector 的哈希码值。

int

indexOf(Object o)

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

int

indexOf(Object o, int index)

返回此向量中指定元素第一次出现的索引，从 index 向前搜索，如果未找到该元素，则返回 -1。

void

insertElementAt(E obj, int index)

将指定对象作为此向量中指定 index 的组件插入。

boolean

isEmpty()

测试此向量是否没有组件。

Iterator<E>

iterator()

以正确的顺序返回此list中元素的迭代器。

E

lastElement()

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

int

lastIndexOf(Object o)

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

int

lastIndexOf(Object o, int index)

返回此向量中指定元素最后一次出现的索引，从 index 向后搜索，如果未找到该元素，则返回 -1。

ListIterator<E>

listIterator()

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

ListIterator<E>

listIterator(int index)

返回此list中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始。

E

remove(int index)

移除此 Vector 中指定位置的元素。

boolean

remove(Object o)

移除此 Vector 中指定元素的第一次出现如果 Vector 不包含该元素，则它保持不变。

boolean

removeAll(Collection<?> c)

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

void

removeAllElements()

从此向量中删除所有组件并将其大小设置为零。

boolean

removeElement(Object obj)

从此向量中移除参数的第一个（最低索引）出现。

void

removeElementAt(int index)

删除指定索引处的组件。

boolean

removeIf(Predicate<? super E> filter)

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

protected void

removeRange(int fromIndex, int toIndex)

从此list中删除索引介于 fromIndex 和 toIndex 之间的所有元素，包括在内。

void

replaceAll(UnaryOperator<E> operator)

将此list的每个元素替换为对该元素应用运算符的结果。

boolean

retainAll(Collection<?> c)

仅保留此 Vector 中包含在指定 Collection 中的元素。

E

set(int index, E element)

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

void

setElementAt(E obj, int index)

将此向量的指定 index 处的组件设置为指定对象。

void

setSize(int newSize)

设置此向量的大小。

int

size()

返回此向量中的组件数。

Spliterator<E>

spliterator()

在此list中的元素上创建 late-binding 和 fail-fast Spliterator 。

List<E>

subList(int fromIndex, int toIndex)

返回此list在 fromIndex（包含）和 toIndex（不包含）之间的部分视图。

Object[]

toArray()

以正确的顺序返回包含此 Vector 中所有元素的数组。

<T> T[]

toArray(T[] a)

以正确的顺序返回包含此 Vector 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

String

toString()

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

void

trimToSize()

将此向量的容量修剪为向量的当前大小。

在类 java.lang.Object 中声明的方法
finalize, getClass, notify, notifyAll, wait, wait, wait

在接口 java.util.Collection 中声明的方法
parallelStream, stream, toArray

在接口 java.util.List 中声明的方法
sort

字段详细信息
- elementData
  
  protected Object [] elementData
  
  存储向量组件的数组缓冲区。向量的容量是这个数组缓冲区的长度，并且至少大到足以包含向量的所有元素。
  Vector 中最后一个元素之后的任何数组元素均为空。
- 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 - 如果指定的集合为空
  
  自从：
  
  1.2
方法详情
- copyInto
  
  public void copyInto(Object [] anArray)
  
  将此向量的组件复制到指定的数组中。此向量中索引为 k 的项目被复制到 anArray 的组件 k 中。
  参数：
  
  anArray - 组件被复制到的数组
  
  抛出：
  
  NullPointerException - 如果给定数组为空
  
  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()
  
  返回此向量中的组件数。
  
  指定者：
  
  size 在接口 Collection<E> 中
  
  指定者：
  
  size 在接口 List<E> 中
  
  返回：
  
  此向量中的组件数
- isEmpty
  
  public boolean isEmpty()
  
  测试此向量是否没有组件。
  
  指定者：
  
  isEmpty 在接口 Collection<E> 中
  
  指定者：
  
  isEmpty 在接口 List<E> 中
  
  重写：
  
  isEmpty 在类 AbstractCollection<E> 中
  
  返回：
  
  true 当且仅当此向量没有组件时，即它的大小为零； false否则。
- elements
  
  public Enumeration <E > elements()
  
  返回此向量的组件的枚举。返回的 Enumeration 对象将生成此向量中的所有项目。生成的第一个项目是索引 0 处的项目，然后是索引 1 处的项目，依此类推。如果在枚举元素时对向量进行了结构修改，则枚举的结果是不确定的。
  返回：
  
  此向量的组件的枚举
  
  参见：
  
  Iterator
- contains
  
  public boolean contains(Object o)
  
  如果此向量包含指定元素，则返回 true。更正式地说，返回 true 当且仅当此向量包含至少一个元素 e 使得 Objects.equals(o, e) 。
  
  指定者：
  
  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
- indexOf
  
  public int indexOf(Object o, int index)
  
  返回此向量中指定元素第一次出现的索引，从 index 向前搜索，如果未找到该元素，则返回 -1。更正式地说，返回最低索引 i 这样 (i >= index && Objects.equals(o, get(i))) ，或 -1 如果没有这样的索引。
  参数：
  
  o - 要搜索的元素
  
  index - 开始搜索的索引
  
  返回：
  
  此向量中第一个元素在向量中位置 index 或之后出现的索引； -1 如果未找到该元素。
  
  抛出：
  
  IndexOutOfBoundsException - 如果指定索引为负
  
  参见：
  
  Object.equals(Object)
- lastIndexOf
  
  public int lastIndexOf(Object o)
  
  返回此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则返回 -1。更正式地说，返回最高索引 i 这样 Objects.equals(o, get(i)) ，或者 -1 如果没有这样的索引。
  
  指定者：
  
  lastIndexOf 在接口 List<E> 中
  
  重写：
  
  lastIndexOf 在类 AbstractList<E> 中
  
  参数：
  
  o - 要搜索的元素
  
  返回：
  
  此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则为 -1
- lastIndexOf
  
  public int lastIndexOf(Object o, int index)
  
  返回此向量中指定元素最后一次出现的索引，从 index 向后搜索，如果未找到该元素，则返回 -1。更正式地说，返回最高索引 i 这样 (i <= index && Objects.equals(o, get(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)
  
  将指定的组件添加到此向量的末尾，将其大小增加一。如果它的大小变得大于它的容量，这个向量的容量就会增加。
  此方法在功能上与 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 对象的原始内部数据数组的引用。
  重写：
  
  clone 在类 Object 中
  
  返回：
  
  这个载体的克隆
  
  参见：
  
  Cloneable
- toArray
  
  public Object [] toArray()
  
  以正确的顺序返回包含此 Vector 中所有元素的数组。
  指定者：
  
  toArray 在接口 Collection<E> 中
  
  指定者：
  
  toArray 在接口 List<E> 中
  
  重写：
  
  toArray 在类 AbstractCollection<E> 中
  
  返回：
  
  一个数组，其运行时组件类型为 Object，包含此集合中的所有元素
  
  自从：
  
  1.2
  
  参见：
  
  Arrays.asList(Object[])
- toArray
  
  public <T> T[] toArray(T[] a)
  
  以正确的顺序返回包含此 Vector 中所有元素的数组；返回数组的运行时类型是指定数组的类型。如果 Vector 适合指定的数组，则在其中返回。否则，将使用指定数组的运行时类型和此 Vector 的大小分配一个新数组。
  如果 Vector 适合指定的数组并有剩余空间（即，数组的元素多于 Vector），则紧跟在 Vector 末尾的数组中的元素将设置为 null。（如果调用者知道 Vector 不包含任何空元素，这对于确定 Vector only 的长度很有用。）
  
  指定者：
  
  toArray 在接口 Collection<E> 中
  
  指定者：
  
  toArray 在接口 List<E> 中
  
  重写：
  
  toArray 在类 AbstractCollection<E> 中
  
  类型参数：
  
  T - 数组元素的类型。与 <E> 相同的类型或 <E> 的超类型。
  
  参数：
  
  a - 要存储 Vector 元素的数组，如果它足够大的话；否则，为此分配一个相同运行时类型的新数组。
  
  返回：
  
  包含 Vector 元素的数组
  
  抛出：
  
  ArrayStoreException - 如果 a 的运行时类型 <T> 不是此 Vector 中每个元素的运行时类型 <E> 的超类型
  
  NullPointerException - 如果给定数组为空
  
  自从：
  
  1.2
- get
  
  public E get(int index)
  
  返回此 Vector 中指定位置的元素。
  
  指定者：
  
  get 在接口 List<E> 中
  
  指定者：
  
  get 在类 AbstractList<E> 中
  
  参数：
  
  index - 要返回的元素的索引
  
  返回：
  
  指定索引处的对象
  
  抛出：
  
  ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
  
  自从：
  
  1.2
- set
  
  public E set(int index, E element)
  
  用指定元素替换此 Vector 中指定位置的元素。
  
  指定者：
  
  set 在接口 List<E> 中
  
  重写：
  
  set 在类 AbstractList<E> 中
  
  参数：
  
  index - 要替换的元素的索引
  
  element - 要存储在指定位置的元素
  
  返回：
  
  先前在指定位置的元素
  
  抛出：
  
  ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
  
  自从：
  
  1.2
- add
  
  public boolean add(E e)
  
  将指定的元素追加到此 Vector 的末尾。
  
  指定者：
  
  add 在接口 Collection<E> 中
  
  指定者：
  
  add 在接口 List<E> 中
  
  重写：
  
  add 在类 AbstractList<E> 中
  
  参数：
  
  e - 要附加到此 Vector 的元素
  
  返回：
  
  true（由 Collection.add(E) 指定）
  
  自从：
  
  1.2
- remove
  
  public boolean remove(Object o)
  
  移除此 Vector 中指定元素的第一次出现如果 Vector 不包含该元素，则它保持不变。更正式地说，删除具有最低索引 i 的元素，例如 Objects.equals(o, get(i))（如果存在这样的元素）。
  
  指定者：
  
  remove 在接口 Collection<E> 中
  
  指定者：
  
  remove 在接口 List<E> 中
  
  重写：
  
  remove 在类 AbstractCollection<E> 中
  
  参数：
  
  o - 要从此 Vector 中删除的元素（如果存在）
  
  返回：
  
  如果 Vector 包含指定元素，则为 true
  
  自从：
  
  1.2
- add
  
  public void add(int index, E element)
  
  在此 Vector 中的指定位置插入指定元素。将当前位于该位置的元素（如果有）和任何后续元素向右移动（将其索引加一）。
  
  指定者：
  
  add 在接口 List<E> 中
  
  重写：
  
  add 在类 AbstractList<E> 中
  
  参数：
  
  index - 要插入指定元素的索引
  
  element - 要插入的元素
  
  抛出：
  
  ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
  
  自从：
  
  1.2
- remove
  
  public E remove(int index)
  
  移除此 Vector 中指定位置的元素。将任何后续元素向左移动（从其索引中减去一个）。返回从 Vector 中删除的元素。
  
  指定者：
  
  remove 在接口 List<E> 中
  
  重写：
  
  remove 在类 AbstractList<E> 中
  
  参数：
  
  index - 要删除的元素的索引
  
  返回：
  
  被移除的元素
  
  抛出：
  
  ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
  
  自从：
  
  1.2
- clear
  
  public void clear()
  
  从此 Vector 中移除所有元素。此调用返回后 Vector 将为空（除非它抛出异常）。
  
  指定者：
  
  clear 在接口 Collection<E> 中
  
  指定者：
  
  clear 在接口 List<E> 中
  
  重写：
  
  clear 在类 AbstractList<E> 中
  
  自从：
  
  1.2
- containsAll
  
  public boolean containsAll(Collection <?> c)
  
  如果此 Vector 包含指定 Collection 中的所有元素，则返回 true。
  指定者：
  
  containsAll 在接口 Collection<E> 中
  
  指定者：
  
  containsAll 在接口 List<E> 中
  
  重写：
  
  containsAll 在类 AbstractCollection<E> 中
  
  参数：
  
  c - 一个集合，其元素将被测试是否包含在此 Vector 中
  
  返回：
  
  如果此 Vector 包含指定集合中的所有元素，则为 true
  
  抛出：
  
  NullPointerException - 如果指定的集合为空
  
  参见：
  
  AbstractCollection.contains(Object)
- addAll
  
  public boolean addAll(Collection <? extends E > c)
  
  将指定 Collection 中的所有元素附加到此 Vector 的末尾，按照它们由指定 Collection 的 Iterator 返回的顺序。如果指定的 Collection 在操作进行时被修改，则此操作的行为是未定义的。（这意味着如果指定的 Collection 是这个 Vector 并且这个 Vector 是非空的，那么这个调用的行为是未定义的。）
  指定者：
  
  addAll 在接口 Collection<E> 中
  
  指定者：
  
  addAll 在接口 List<E> 中
  
  重写：
  
  addAll 在类 AbstractCollection<E> 中
  
  参数：
  
  c - 要插入到此 Vector 中的元素
  
  返回：
  
  true 如果此 Vector 因调用而更改
  
  抛出：
  
  NullPointerException - 如果指定的集合为空
  
  自从：
  
  1.2
  
  参见：
  
  AbstractCollection.add(Object)
- removeAll
  
  public boolean removeAll(Collection <?> c)
  
  从此 Vector 中移除指定 Collection 中包含的所有元素。
  指定者：
  
  removeAll 在接口 Collection<E> 中
  
  指定者：
  
  removeAll 在接口 List<E> 中
  
  重写：
  
  removeAll 在类 AbstractCollection<E> 中
  
  参数：
  
  c - 要从 Vector 中删除的元素的集合
  
  返回：
  
  如果此 Vector 因调用而更改，则为 true
  
  抛出：
  
  ClassCastException - 如果此向量中一个或多个元素的类型与指定集合不兼容 (optional)
  
  NullPointerException - 如果此向量包含一个或多个空元素并且指定的集合不支持空元素 (optional)，或者如果指定的集合为空
  
  自从：
  
  1.2
  
  参见：
  
  AbstractCollection.remove(Object)
  
  AbstractCollection.contains(Object)
- retainAll
  
  public boolean retainAll(Collection <?> c)
  
  仅保留此 Vector 中包含在指定 Collection 中的元素。换句话说，从该 Vector 中移除所有未包含在指定 Collection 中的元素。
  指定者：
  
  retainAll 在接口 Collection<E> 中
  
  指定者：
  
  retainAll 在接口 List<E> 中
  
  重写：
  
  retainAll 在类 AbstractCollection<E> 中
  
  参数：
  
  c - 要保留在此 Vector 中的元素集合（所有其他元素均已删除）
  
  返回：
  
  如果此 Vector 因调用而更改，则为 true
  
  抛出：
  
  ClassCastException - 如果此向量中一个或多个元素的类型与指定集合不兼容 (optional)
  
  NullPointerException - 如果此向量包含一个或多个空元素并且指定的集合不支持空元素 (optional)，或者如果指定的集合为空
  
  自从：
  
  1.2
  
  参见：
  
  AbstractCollection.remove(Object)
  
  AbstractCollection.contains(Object)
- removeIf
  
  public boolean removeIf(Predicate <? super E > filter)
  
  从接口 Collection 复制的描述
  
  移除此集合中满足给定谓词的所有元素。迭代期间或由谓词抛出的错误或运行时异常将传递给调用者。
  
  指定者：
  
  removeIf 在接口 Collection<E> 中
  
  参数：
  
  filter - 为要删除的元素返回 true 的谓词
  
  返回：
  
  true 如果删除了任何元素
  
  抛出：
  
  NullPointerException - 如果指定的过滤器为空
- addAll
  
  public boolean addAll(int index, Collection <? extends E > c)
  
  将指定 Collection 中的所有元素插入此 Vector 的指定位置。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。新元素将按照指定 Collection 的迭代器返回的顺序出现在 Vector 中。
  
  指定者：
  
  addAll 在接口 List<E> 中
  
  重写：
  
  addAll 在类 AbstractList<E> 中
  
  参数：
  
  index - 从指定集合中插入第一个元素的索引
  
  c - 要插入到此 Vector 中的元素
  
  返回：
  
  true 如果此 Vector 因调用而更改
  
  抛出：
  
  ArrayIndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
  
  NullPointerException - 如果指定的集合为空
  
  自从：
  
  1.2
- equals
  
  public boolean equals(Object o)
  
  比较指定的 Object 与此 Vector 是否相等。当且仅当指定的 Object 也是一个 List 时返回 true，两个 List 具有相同的大小，并且两个 List 中所有对应的元素对都是 equal 。（两个元素 e1 和 e2 是 equal if Objects.equals(e1, e2) 。）换句话说，如果两个列表包含相同顺序的相同元素，则它们被定义为相等。
  指定者：
  
  equals 在接口 Collection<E> 中
  
  指定者：
  
  equals 在接口 List<E> 中
  
  重写：
  
  equals 在类 AbstractList<E> 中
  
  参数：
  
  o - 要与此 Vector 进行比较的对象
  
  返回：
  
  如果指定的对象等于此向量，则为真
  
  参见：
  
  Object.hashCode()
  
  HashMap
- hashCode
  
  public int hashCode()
  
  返回此 Vector 的哈希码值。
  指定者：
  
  hashCode 在接口 Collection<E> 中
  
  指定者：
  
  hashCode 在接口 List<E> 中
  
  重写：
  
  hashCode 在类 AbstractList<E> 中
  
  返回：
  
  此list的哈希码值
  
  参见：
  
  Object.equals(java.lang.Object)
  
  System.identityHashCode(java.lang.Object)
- toString
  
  public String toString()
  
  返回此 Vector 的字符串表示形式，其中包含每个元素的字符串表示形式。
  
  重写：
  
  toString 在类 AbstractCollection<E> 中
  
  返回：
  
  此集合的字符串表示形式
- subList
  
  public List <E > subList(int fromIndex, int toIndex)
  返回此list在 fromIndex（包含）和 toIndex（不包含）之间的部分视图。（如果 fromIndex 和 toIndex 相等，则返回的 List 为空。）返回的 List 受此 List 支持，因此返回的 List 中的更改会反映在此 List 中，反之亦然。返回的列表支持此list支持的所有可选列表操作。
  此方法消除了对显式范围操作（数组通常存在的那种）的需要。通过对子列表视图而不是整个列表进行操作，任何需要列表的操作都可以用作范围操作。例如，以下习语从列表中删除一系列元素：
  
  list.subList(from, to).clear();
  可以为 indexOf 和 lastIndexOf 构造类似的习语，并且 Collections 类中的所有算法都可以应用于子列表。
  如果后备列表（即此list）是结构修改除了通过返回的列表以外的任何方式。（结构修改是那些改变列表大小的修改，或者以其他方式扰乱它，以至于正在进行的迭代可能会产生不正确的结果。）
  指定者：
  
  subList 在接口 List<E> 中
  
  重写：
  
  subList 在类 AbstractList<E> 中
  
  参数：
  
  fromIndex - subList 的低端点（包括）
  
  toIndex - 子列表的高端点（不包括）
  
  返回：
  
  此list中指定范围的视图
  
  抛出：
  
  IndexOutOfBoundsException - 如果端点索引值超出范围 (fromIndex < 0 || toIndex > size)
  
  IllegalArgumentException - 如果端点索引乱序 (fromIndex > toIndex)
- removeRange
  
  protected void removeRange(int fromIndex, int toIndex)
  
  从此list中删除索引介于 fromIndex 和 toIndex 之间的所有元素，包括在内。将任何后续元素向左移动（减少它们的索引）。此调用将列表缩短 (toIndex - fromIndex) 个元素。（如果 toIndex==fromIndex ，此操作无效。）
  
  重写：
  
  removeRange 在类 AbstractList<E> 中
  
  参数：
  
  fromIndex - 要删除的第一个元素的索引
  
  toIndex - 要删除的最后一个元素之后的索引
- listIterator
  
  public ListIterator <E > listIterator(int index)
  
  返回此list中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始。指定的索引指示将由对 next 的初始调用返回的第一个元素。对 previous 的初始调用将返回指定索引减一的元素。
  返回的列表迭代器是 快速失败 。
  
  指定者：
  
  listIterator 在接口 List<E> 中
  
  重写：
  
  listIterator 在类 AbstractList<E> 中
  
  参数：
  
  index - 从列表迭代器返回的第一个元素的索引（通过调用 next ）
  
  返回：
  
  列表中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
- listIterator
  
  public ListIterator <E > listIterator()
  
  返回此list中元素的列表迭代器（以正确的顺序）。
  返回的列表迭代器是 快速失败 。
  指定者：
  
  listIterator 在接口 List<E> 中
  
  重写：
  
  listIterator 在类 AbstractList<E> 中
  
  返回：
  
  此list中元素的列表迭代器（按正确顺序）
  
  参见：
  
  listIterator(int)
- iterator
  
  public Iterator <E > iterator()
  
  以正确的顺序返回此list中元素的迭代器。
  返回的迭代器是 快速失败 。
  
  指定者：
  
  iterator 在接口 Collection<E> 中
  
  指定者：
  
  iterator 在接口 Iterable<E> 中
  
  指定者：
  
  iterator 在接口 List<E> 中
  
  重写：
  
  iterator 在类 AbstractList<E> 中
  
  返回：
  
  按正确顺序遍历此list中的元素的迭代器
- forEach
  
  public void forEach(Consumer <? super E > action)
  
  从接口 Iterable 复制的描述
  
  对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或操作引发异常。如果指定了迭代顺序，则将按迭代顺序执行操作。操作抛出的异常被转发给调用者。
  如果操作执行修改元素的底层源的副作用，则此方法的行为是未指定的，除非重写类已指定并发修改策略。
  
  指定者：
  
  forEach 在接口 Iterable<E> 中
  
  参数：
  
  action - 对每个元素执行的操作
  
  抛出：
  
  NullPointerException - 如果指定的操作为空
- replaceAll
  
  public void replaceAll(UnaryOperator <E > operator)
  
  从接口 List 复制的描述
  
  将此list的每个元素替换为对该元素应用运算符的结果。操作员抛出的错误或运行时异常被转发给调用者。
  
  指定者：
  
  replaceAll 在接口 List<E> 中
  
  参数：
  
  operator - 应用于每个元素的运算符
  
  抛出：
  
  NullPointerException - 如果指定的运算符为空或运算符结果为空值且此list不允许空元素 (optional)
- spliterator
  
  public Spliterator <E > spliterator()
  
  在此list中的元素上创建 late-binding 和 fail-fast Spliterator 。
  Spliterator 报告 Spliterator.SIZED 、Spliterator.SUBSIZED 和 Spliterator.ORDERED 。覆盖实施应记录附加特征值的报告。
  
  指定者：
  
  spliterator 在接口 Collection<E> 中
  
  指定者：
  
  spliterator 在接口 Iterable<E> 中
  
  指定者：
  
  spliterator 在接口 List<E> 中
  
  返回：
  
  a Spliterator 覆盖此list中的元素
  
  自从：
  
  1.8

类 Vector<E>

字段摘要

在类 java.util.AbstractList 中声明的字段

构造方法总结

方法总结

在类 java.lang.Object 中声明的方法

在接口 java.util.Collection 中声明的方法

在接口 java.util.List 中声明的方法

字段详细信息

elementData

elementCount

capacityIncrement

构造方法详细信息

Vector

Vector

Vector

Vector

方法详情

copyInto

trimToSize

ensureCapacity

setSize

capacity

size

isEmpty

elements

contains

indexOf

indexOf

lastIndexOf

lastIndexOf

elementAt

firstElement

lastElement

setElementAt

removeElementAt

insertElementAt

addElement

removeElement

removeAllElements

clone

toArray

toArray

get

set

add

remove

add

remove

clear

containsAll

addAll

removeAll

retainAll

removeIf

addAll

equals

hashCode

toString

subList

removeRange

listIterator

listIterator

iterator

forEach

replaceAll

spliterator