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

All Implemented Interfaces:

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优化存储capacityIncrement 。 capacity总是至少与矢量大小一样大; 通常较大，因为当向量中添加组分时，向量的存储空间大小capacityIncrement 。应用程序可以在插入大量组件之前增加向量的容量; 这减少了增量重新分配的数量。

The iterators returned by this class's个 iterator和listIterator方法是快速失败的 ：如果向量在任何时间从结构上修改创建迭代器之后，以任何方式除非通过迭代器自身remove种或add方法，迭代器都将抛出一个ConcurrentModificationException 。因此，面对并发修改，迭代器将快速而干净地失败，而不是在未来未确定的时间冒着任意的非确定性行为。由elements返回的Enumerations 不是故障快速的。

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

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

从以下版本开始：

JDK1.0

另请参见：

Collection ， LinkedList ， Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`capacityIncrement` 当矢量的大小大于其容量时，矢量的容量自动增加的量。
`protected int`	`elementCount` 该 `Vector`对象中有效组件的数量。
`protected Object[]`	`elementData` 存储向量的组件的阵列缓冲区。

Fields inherited from class java.util.AbstractList
modCount

构造方法摘要

构造方法
Constructor and Description
`Vector()` 构造一个空向量，使其内部数据数组的大小为 `10` ，标准容量增量为零。
`Vector(Collection<? extends E> c)` 构造一个包含指定集合元素的向量，按照集合的迭代器返回的顺序。
`Vector(int initialCapacity)` 构造具有指定初始容量并且其容量增量等于零的空向量。
`Vector(int initialCapacity, int capacityIncrement)` 构造具有指定的初始容量和容量增量的空向量。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`boolean`	`add(E e)` 将指定的元素追加到此Vector的末尾。
`void`	`add(int index, E element)` 在此Vector中的指定位置插入指定的元素。
`boolean`	`addAll(Collection<? extends E> c)` 将指定集合中的所有元素追加到该向量的末尾，按照它们由指定集合的迭代器返回的顺序。
`boolean`	`addAll(int index, Collection<? extends E> c)` 将指定集合中的所有元素插入到此向量中的指定位置。
`void`	`addElement(E obj)` 将指定的组件添加到此向量的末尾，将其大小增加1。
`int`	`capacity()` 返回此向量的当前容量。
`void`	`clear()` 从此Vector中删除所有元素。
`Object`	`clone()` 返回此向量的克隆。
`boolean`	`contains(Object o)` 如果此向量包含指定的元素，则返回 `true` 。
`boolean`	`containsAll(Collection<?> c)` 如果此向量包含指定集合中的所有元素，则返回true。
`void`	`copyInto(Object[] anArray)` 将此向量的组件复制到指定的数组中。
`E`	`elementAt(int index)` 返回指定索引处的组件。
`Enumeration<E>`	`elements()` 返回此向量的组件的枚举。
`void`	`ensureCapacity(int minCapacity)` 如果需要，增加此向量的容量，以确保它可以至少保存最小容量参数指定的组件数。
`boolean`	`equals(Object o)` 将指定的对象与此向量进行比较以获得相等性。
`E`	`firstElement()` 返回此向量的第一个组件（索引号为 `0`的项目）。
`void`	`forEach(Consumer<? super E> action)` 对 `Iterable`的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。
`E`	`get(int index)` 返回此向量中指定位置的元素。
`int`	`hashCode()` 返回此Vector的哈希码值。
`int`	`indexOf(Object o)` 返回此向量中指定元素的第一次出现的索引，如果此向量不包含元素，则返回-1。
`int`	`indexOf(Object o, int index)` 返回此向量中指定元素的第一次出现的索引，从 `index`向前 `index` ，如果未找到该元素，则返回-1。
`void`	`insertElementAt(E obj, int index)` 在指定的index插入指定对象作为该向量中的一个 `index` 。
`boolean`	`isEmpty()` 测试此矢量是否没有组件。
`Iterator<E>`	`iterator()` 以正确的顺序返回该列表中的元素的迭代器。
`E`	`lastElement()` 返回向量的最后一个组件。
`int`	`lastIndexOf(Object o)` 返回此向量中指定元素的最后一次出现的索引，如果此向量不包含元素，则返回-1。
`int`	`lastIndexOf(Object o, int index)` 返回此向量中指定元素的最后一次出现的索引，从 `index` ，如果未找到元素，则返回-1。
`ListIterator<E>`	`listIterator()` 返回列表中的列表迭代器（按适当的顺序）。
`ListIterator<E>`	`listIterator(int index)` 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
`E`	`remove(int index)` 删除此向量中指定位置的元素。
`boolean`	`remove(Object o)` 删除此向量中指定元素的第一个出现如果Vector不包含元素，则它不会更改。
`boolean`	`removeAll(Collection<?> c)` 从此Vector中删除指定集合中包含的所有元素。
`void`	`removeAllElements()` 从该向量中删除所有组件，并将其大小设置为零。
`boolean`	`removeElement(Object obj)` 从此向量中删除参数的第一个（最低索引）出现次数。
`void`	`removeElementAt(int index)` 删除指定索引处的组件。
`boolean`	`removeIf(Predicate<? super E> filter)` 删除满足给定谓词的此集合的所有元素。
`protected void`	`removeRange(int fromIndex, int toIndex)` 从此列表中删除所有索引为 `fromIndex` （含）和 `toIndex`之间的元素。
`void`	`replaceAll(UnaryOperator<E> operator)` 将该列表的每个元素替换为将该运算符应用于该元素的结果。
`boolean`	`retainAll(Collection<?> c)` 仅保留此向量中包含在指定集合中的元素。
`E`	`set(int index, E element)` 用指定的元素替换此Vector中指定位置的元素。
`void`	`setElementAt(E obj, int index)` 设置在指定的组件 `index`此向量的要指定的对象。
`void`	`setSize(int newSize)` 设置此向量的大小。
`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()` 以正确的顺序返回一个包含此Vector中所有元素的数组。
`<T> T[]`	`toArray(T[] a)` 以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
`String`	`toString()` 返回此Vector的字符串表示形式，其中包含每个元素的String表示形式。
`void`	`trimToSize()` 修改该向量的容量成为向量的当前大小。

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Collection
parallelStream, stream

- 字段详细信息
  - 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 。
    
    参数
    
    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()
```
    返回此向量中的组件数。
    
    Specified by:
    
    size在界面 Collection<E>
    
    Specified by:
    
    size在接口 List<E>
    
    Specified by:
    
    size在 AbstractCollection<E>
    
    结果
    
    该向量中的组件数量
  - isEmpty
```
public boolean isEmpty()
```
    测试此矢量是否没有组件。
    
    Specified by:
    
    isEmpty在界面 Collection<E>
    
    Specified by:
    
    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使得(o==null ? e==null : o.equals(e)) 。
    
    Specified by:
    
    contains在界面 Collection<E>
    
    Specified by:
    
    contains在界面 List<E>
    
    重写：
    
    contains在 AbstractCollection<E>
    
    参数
    
    o - 要在此矢量中存在的元素将被测试
    
    结果
    
    true如果此向量包含指定的元素
  - indexOf
```
public int indexOf(Object o)
```
    返回此向量中指定元素的第一次出现的索引，如果此向量不包含元素，则返回-1。更正式地，返回最低指数i ，使(o==null ? get(i)==null : o.equals(get(i))) ，或-1如果没有这样的指数。
    
    Specified by:
    
    indexOf在界面 List<E>
    
    重写：
    
    indexOf在 AbstractList<E>
    
    参数
    
    o - 要搜索的元素
    
    结果
    
    该向量中指定元素的第一次出现的索引，如果此向量不包含元素，则为-1
  - indexOf
```
public int indexOf(Object o,
                   int index)
```
    返回此向量中指定元素的第一次出现的索引，从index向前index ，如果未找到该元素，则返回-1。更正式地，返回最低指数i ，使(i >= index && (o==null ? get(i)==null : o.equals(get(i)))) ，或-1如果没有这样的索引。
    
    参数
    
    o - 要搜索的元素
    
    index - 开始搜索的索引
    
    结果
    
    该向量中元素第一次出现的位置在向量中的位置index或更高的位置的index ; -1如果没有找到该元素。
    
    异常
    
    IndexOutOfBoundsException - 如果指定的索引为负数
    
    另请参见：
    
    Object.equals(Object)
  - lastIndexOf
```
public int lastIndexOf(Object o)
```
    返回此向量中指定元素的最后一次出现的索引，如果此向量不包含元素，则返回-1。更正式地，返回最高指数i ，使(o==null ? get(i)==null : o.equals(get(i))) ，或-1如果没有这样的索引。
    
    Specified by:
    
    lastIndexOf在界面 List<E>
    
    重写：
    
    lastIndexOf在类别 AbstractList<E>
    
    参数
    
    o - 要搜索的元素
    
    结果
    
    该向量中指定元素的最后一次出现的索引，如果此向量不包含元素，则为-1
  - lastIndexOf
```
public int lastIndexOf(Object o,
                       int index)
```
    返回此向量中指定元素的最后一次出现的索引，从index ，如果未找到该元素，则返回-1。更正式地，返回最高指数i ，使(i <= index && (o==null ? get(i)==null : o.equals(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 。
    索引必须大于或等于0 ，小于当前的向量大小。
    
    该方法的功能与remove(int)方法相同（它是List接口的一部分）。请注意， remove方法返回存储在指定位置的旧值。
    
    参数
    
    index - 要删除的对象的索引
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）
  - insertElementAt
```
public void insertElementAt(E obj,
                            int index)
```
    在指定的index插入指定对象作为此向量中的index 。该向量中具有大于或等于指定值index的索引中的每个index向上移动以使索引一大于先前的值。
    索引必须大于或等于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)
```
    从此向量中删除参数的第一个（最低索引）出现次数。如果在该向量中找到对象，则向量中具有大于或等于对象索引的索引的向量中的每个组件向下移动，以使索引小于之前的值。
    该方法的功能与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中所有元素的数组。
    
    Specified by:
    
    toArray在界面 Collection<E>
    
    Specified by:
    
    toArray在界面 List<E>
    
    重写：
    
    toArray在 AbstractCollection<E>
    
    结果
    
    一个包含此集合中所有元素的数组
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    Arrays.asList(Object[])
  - toArray
```
public <T> T[] toArray(T[] a)
```
    以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。如果Vector适合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此Vector的大小分配一个新数组。
    如果向量适合指定的数组，其余空间（即，该数组具有比Vector更多的元素），则紧接在Vector结束之后的数组中的元素将设置为null。（仅当调用者知道Vector不包含任何空元素时，这才有助于确定Vector的长度。）
    
    Specified by:
    
    toArray在接口 Collection<E>
    
    Specified by:
    
    toArray在界面 List<E>
    
    重写：
    
    toArray在类别 AbstractCollection<E>
    
    参数类型
    
    T - 包含集合的数组的运行时类型
    
    参数
    
    a - 要存储Vector的元素的数组，如果它足够大; 否则，为此目的分配相同运行时类型的新数组。
    
    结果
    
    一个包含Vector元素的数组
    
    异常
    
    ArrayStoreException - 如果a的运行时类型不是此向量中每个元素的运行时类型的超类型
    
    NullPointerException - 如果给定的数组为空
    
    从以下版本开始：
    
    1.2
  - get
```
public E get(int index)
```
    返回此向量中指定位置的元素。
    
    Specified by:
    
    get在界面 List<E>
    
    Specified by:
    
    get在类别 AbstractList<E>
    
    参数
    
    index - 要返回的元素的索引
    
    结果
    
    对象在指定的索引
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）
    
    从以下版本开始：
    
    1.2
  - set
```
public E set(int index,
             E element)
```
    用指定的元素替换此Vector中指定位置的元素。
    
    Specified by:
    
    set在界面 List<E>
    
    重写：
    
    set在 AbstractList<E>
    
    参数
    
    index - 要替换的元素的索引
    
    element - 要存储在指定位置的元素
    
    结果
    
    该元素以前在指定的位置
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）
    
    从以下版本开始：
    
    1.2
  - add
```
public boolean add(E e)
```
    将指定的元素追加到此Vector的末尾。
    
    Specified by:
    
    add在接口 Collection<E>
    
    Specified by:
    
    add在界面 List<E>
    
    重写：
    
    add在类别 AbstractList<E>
    
    参数
    
    e - 要附加到此向量的元素
    
    结果
    
    true （由 Collection.add(E)指定）
    
    从以下版本开始：
    
    1.2
  - remove
```
public boolean remove(Object o)
```
    删除此向量中指定元素的第一个出现如果Vector不包含元素，则它不会更改。更正式地，删除具有最低索引i的元素，使得(o==null ? get(i)==null : o.equals(get(i))) （如果这样的元素存在）。
    
    Specified by:
    
    remove在接口 Collection<E>
    
    Specified by:
    
    remove在界面 List<E>
    
    重写：
    
    remove在 AbstractCollection<E>
    
    参数
    
    o - 要从此Vector中移除的元素（如果存在）
    
    结果
    
    如果Vector包含指定的元素，则为true
    
    从以下版本开始：
    
    1.2
  - add
```
public void add(int index,
                E element)
```
    在此Vector中的指定位置插入指定的元素。将当前位于该位置的元素（如果有）和任何后续元素（向其索引添加一个）移动。
    
    Specified by:
    
    add在界面 List<E>
    
    重写：
    
    add在 AbstractList<E>
    
    参数
    
    index - 要在其中插入指定元素的索引
    
    element - 要插入的元素
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index > size() ）
    
    从以下版本开始：
    
    1.2
  - remove
```
public E remove(int index)
```
    删除此向量中指定位置的元素。将任何后续元素移动到左侧（从其索引中减去一个元素）。返回从Vector中删除的元素。
    
    Specified by:
    
    remove在界面 List<E>
    
    重写：
    
    remove在 AbstractList<E>
    
    参数
    
    index - 要删除的元素的索引
    
    结果
    
    元素被删除
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）
    
    从以下版本开始：
    
    1.2
  - clear
```
public void clear()
```
    从此Vector中删除所有元素。此调用返回后，Vector将为空（除非引发异常）。
    
    Specified by:
    
    clear在界面 Collection<E>
    
    Specified by:
    
    clear在界面 List<E>
    
    重写：
    
    clear在类别 AbstractList<E>
    
    从以下版本开始：
    
    1.2
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    如果此向量包含指定集合中的所有元素，则返回true。
    
    Specified by:
    
    containsAll在界面 Collection<E>
    
    Specified by:
    
    containsAll在界面 List<E>
    
    重写：
    
    containsAll在类别 AbstractCollection<E>
    
    参数
    
    c - 一个集合，其元素将在此向量中进行遏制测试
    
    结果
    
    如果此向量包含指定集合中的所有元素，则为true
    
    异常
    
    NullPointerException - 如果指定的集合为空
    
    另请参见：
    
    AbstractCollection.contains(Object)
  - addAll
```
public boolean addAll(Collection<? extends E> c)
```
    将指定集合中的所有元素追加到该向量的末尾，按照它们由指定集合的迭代器返回的顺序。如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。（这意味着如果指定的集合是此Vector，则此调用的行为是未定义的，并且此向量是非空的。）
    
    Specified by:
    
    addAll在界面 Collection<E>
    
    Specified by:
    
    addAll在界面 List<E>
    
    重写：
    
    addAll在类别 AbstractCollection<E>
    
    参数
    
    c - 要插入此向量的元素
    
    结果
    
    true如果此向量由于调用而更改
    
    异常
    
    NullPointerException - 如果指定的集合为空
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    AbstractCollection.add(Object)
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    从此Vector中删除指定集合中包含的所有元素。
    
    Specified by:
    
    removeAll在接口 Collection<E>
    
    Specified by:
    
    removeAll在接口 List<E>
    
    重写：
    
    removeAll在 AbstractCollection<E>
    
    参数
    
    c - 要从Vector中删除的元素的集合
    
    结果
    
    如果此向量由于调用而更改，则为true
    
    异常
    
    ClassCastException - 如果此向量中的一个或多个元素的类型与指定的集合不兼容（ optional ）
    
    NullPointerException - 如果此向量包含一个或多个空元素，并且指定的集合不支持空元素（ optional ），或者如果指定的集合为空
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    仅保留此向量中包含在指定集合中的元素。换句话说，从此Vector中删除所有不包含在指定集合中的元素。
    
    Specified by:
    
    retainAll在界面 Collection<E>
    
    Specified by:
    
    retainAll在界面 List<E>
    
    重写：
    
    retainAll在类别 AbstractCollection<E>
    
    参数
    
    c - 要保留在此向量中的所有元素的集合（所有其他元素都被删除）
    
    结果
    
    如果此向量由于调用而更改，则为true
    
    异常
    
    ClassCastException - 如果此向量中的一个或多个元素的类型与指定的集合不兼容（ optional ）
    
    NullPointerException - 如果此向量包含一个或多个空元素，并且指定的集合不支持空元素（ optional ），或者如果指定的集合为空
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)
  - addAll
```
public boolean addAll(int index,
                      Collection<? extends E> c)
```
    将指定集合中的所有元素插入到此向量中的指定位置。将当前位于该位置（如果有的话）的元素和随后的任何元素移动到右边（增加其索引）。新元素将按照它们由指定的集合的迭代器返回的顺序显示在Vector中。
    
    Specified by:
    
    addAll在界面 List<E>
    
    重写：
    
    addAll在 AbstractList<E>类
    
    参数
    
    index - 从中指定集合插入第一个元素的索引
    
    c - 要插入此向量的元素
    
    结果
    
    true如果此向量由于调用而更改
    
    异常
    
    ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index > size() ）
    
    NullPointerException - 如果指定的集合为空
    
    从以下版本开始：
    
    1.2
  - equals
```
public boolean equals(Object o)
```
    将指定的对象与此向量进行比较以获得相等性。如果且仅当指定的对象也是列表时，则返回true，两个列表的大小相同，并且两个列表中所有相应的元素对相等。（如果(e1==null ? e2==null : e1.equals(e2))两个元素e1和e2 相等）。换句话说，如果两个列表以相同的顺序包含相同的元素，则它们被定义为相等。
    
    Specified by:
    
    equals在界面 Collection<E>
    
    Specified by:
    
    equals在界面 List<E>
    
    重写：
    
    equals在 AbstractList<E>
    
    参数
    
    o - 要与此向量相等的对象进行比较
    
    结果
    
    如果指定的Object等于此Vector，则为true
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    返回此Vector的哈希码值。
    
    Specified by:
    
    hashCode在界面 Collection<E>
    
    Specified by:
    
    hashCode在界面 List<E>
    
    重写：
    
    hashCode在类别 AbstractList<E>
    
    结果
    
    该列表的哈希码值
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    返回此Vector的字符串表示形式，其中包含每个元素的String表示形式。
    
    重写：
    
    toString在 AbstractCollection<E>
    
    结果
    
    此集合的字符串表示形式
  - subList
```
public List<E> subList(int fromIndex,
                       int toIndex)
```
    返回此列表之间的fromIndex（包括）和toIndex之间的独占视图。（如果fromIndex和toIndex相等，则返回的列表为空。）返回的列表由此列表支持，因此返回的列表中的更改将反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。
    该方法消除了对显式范围操作（对于数组通常存在的排序）的需要。任何期望列表的操作都可以通过在子列表视图而不是整个列表中进行操作来用作范围操作。例如，以下成语从列表中删除了一系列元素：
```
  list.subList(from, to).clear(); 
```
    可以为indexOf和lastIndexOf构造类似的成语，并且Collections类中的所有算法都可以应用于子列表。
    如果支持列表（即，此列表）以除了通过返回的列表之外的任何方式进行结构修改 ，则此方法返回的列表的语义将变得未定义。（结构修改是那些改变List的大小，或以其他方式扰乱它，使得正在进行的迭代可能产生不正确的结果）。
    Specified by:
    
    subList在界面 List<E>
    
    重写：
    
    subList在 AbstractList<E>
    
    参数
    
    fromIndex - fromIndex低端点（含）
    
    toIndex - toIndex高端点（排他性）
    
    结果
    
    该列表中指定范围的视图
    
    异常
    
    IndexOutOfBoundsException - 如果端点索引值超出范围 (fromIndex < 0 || toIndex > size)
    
    IllegalArgumentException - 如果端点索引 (fromIndex > toIndex)
  - removeRange
```
protected void removeRange(int fromIndex,
                           int toIndex)
```
    从此列表中删除索引为fromIndex （含）和toIndex之间的所有元素。将任何后续元素移动到左侧（减少其索引）。此电话会通过(toIndex - fromIndex)元素(toIndex - fromIndex)列表。（如果toIndex==fromIndex ，此操作无效）
    
    重写：
    
    removeRange在 AbstractList<E>
    
    参数
    
    fromIndex - 要删除的第一个元素的索引
    
    toIndex - 要删除的最后一个元素后的索引
  - listIterator
```
public ListIterator<E> listIterator(int index)
```
    从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。指定的索引表示初始调用next将返回的第一个元素。对previous的初始调用将返回指定索引减1的元素。
    返回的列表迭代器是fail-fast 。
    
    Specified by:
    
    listIterator在接口 List<E>
    
    重写：
    
    listIterator在 AbstractList<E>
    
    参数
    
    index - 要从列表迭代器返回的第一个元素的索引（通过调用 next ）
    
    结果
    
    在列表中的元素（按正确顺序）的列表迭代器，从列表中的指定位置开始
    
    异常
    
    IndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index > size() ）
  - listIterator
```
public ListIterator<E> listIterator()
```
    返回列表中的列表迭代器（按适当的顺序）。
    返回的列表迭代器是fail-fast 。
    
    Specified by:
    
    listIterator在界面 List<E>
    
    重写：
    
    listIterator在 AbstractList<E>
    
    结果
    
    在列表中的元素的列表迭代器（按适当的顺序）
    
    另请参见：
    
    listIterator(int)
  - iterator
```
public Iterator<E> iterator()
```
    以正确的顺序返回该列表中的元素的迭代器。
    返回的迭代器是fail-fast 。
    
    Specified by:
    
    iterator在界面 Iterable<E>
    
    Specified by:
    
    iterator在接口 Collection<E>
    
    Specified by:
    
    iterator在界面 List<E>
    
    重写：
    
    iterator在 AbstractList<E>
    
    结果
    
    在这个列表中的元素以适当的顺序迭代
  - forEach
```
public void forEach(Consumer<? super E> action)
```
    说明从界面： Iterable复制
    
    对Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。除非实现类另有规定，否则按照迭代的顺序执行操作（如果指定了迭代顺序）。动作抛出的异常被转发给呼叫者。
    
    Specified by:
    
    forEach在界面 Iterable<E>
    
    参数
    
    action - 要为每个元素执行的操作
  - removeIf
```
public boolean removeIf(Predicate<? super E> filter)
```
    说明从界面： Collection复制
    
    删除满足给定谓词的此集合的所有元素。在迭代或谓词中抛出的错误或运行时异常被转发给调用者。
    
    Specified by:
    
    removeIf在界面 Collection<E>
    
    参数
    
    filter - 一个谓词，为要删除的元素返回 true
    
    结果
    
    true如果有任何元素被删除
  - replaceAll
```
public void replaceAll(UnaryOperator<E> operator)
```
    说明从界面： List复制
    
    将该列表的每个元素替换为将该运算符应用于该元素的结果。运营商抛出的错误或运行时异常被转发给呼叫者。
    
    Specified by:
    
    replaceAll在界面 List<E>
    
    参数
    
    operator - 运算符应用于每个元素
  - sort
```
public void sort(Comparator<? super E> c)
```
    描述从界面： List复制
    
    使用提供的 Comparator对此列表进行排序，以比较元素。
    
    Specified by:
    
    sort在接口 List<E>
    
    参数
    
    c - 用于比较列表元素的Comparator 。 A null值表示应使用元素' natural ordering '
  - spliterator
```
public Spliterator<E> spliterator()
```
    在此列表中的元素上创建late-binding和故障切换 Spliterator 。
    该Spliterator报告Spliterator.SIZED ， Spliterator.SUBSIZED和Spliterator.ORDERED 。覆盖实现应记录其他特征值的报告。
    
    Specified by:
    
    spliterator在界面 Iterable<E>
    
    Specified by:
    
    spliterator在界面 Collection<E>
    
    Specified by:
    
    spliterator在界面 List<E>
    
    结果
    
    一个 Spliterator在这个列表中的元素
    
    从以下版本开始：
    
    1.8

Class Vector<E>

Field Summary

Fields inherited from class java.util.AbstractList

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

字段详细信息

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

addAll

equals

hashCode

toString

subList

removeRange

listIterator

listIterator

iterator

forEach

removeIf

replaceAll

sort

spliterator