Module java.base

Package java.util

Class Vector<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.Vector<E>

类型参数:

E - 组件元素的类型

所有实现的接口:

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

直接已知的子类:

Stack

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

Vector 类实现了一个可增长的对象数组。类似于数组，它包含可以使用整数索引访问的组件。但是，Vector 的大小可以根据需要增长或缩小，以适应在创建Vector之后添加和删除项目。

每个向量都尝试通过维护一个capacity和一个capacityIncrement来优化存储管理。 capacity始终至少与向量大小一样大；通常更大，因为当组件添加到向量时，向量的存储会以capacityIncrement大小的块增加。应用程序可以在插入大量组件之前增加向量的容量；这减少了逐步重新分配的量。

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

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

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

自版本:

1.0

参见:

• Collection
• LinkedList
• Serialized Form

Field Summary

Fields

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

Fields declared in class java.util.AbstractList

modCount

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	Description
void	add(int index, E element)	在此向量中的指定位置插入指定元素。
boolean	add(E e)	将指定元素追加到此向量的末尾。
boolean	addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入到此向量的指定位置。
boolean	addAll(Collection<? extends E> c)	将指定集合中的所有元素追加到此向量的末尾，顺序与指定集合的迭代器返回的顺序相同。
void	addElement(E obj)	将指定组件添加到此向量的末尾，将其大小增加一。
int	capacity()	返回此向量的当前容量。
void	clear()	从此向量中删除所有元素。
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()	返回此向量的哈希码值。
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()	返回此列表中元素的迭代器，按正确顺序。
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)	从此向量中删除指定元素的第一次出现。如果向量不包含元素，则保持不变。
boolean	removeAll(Collection<?> c)	从此向量中删除包含在指定集合中的所有元素。
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)	用指定元素替换此向量中指定位置的元素。
void	setElementAt(E obj, int index)	将此向量的指定index处的组件设置为指定对象。
void	setSize(int newSize)	设置此向量的大小。
int	size()	返回此向量中的组件数。
Spliterator<E>	spliterator()	在此列表中的元素上创建一个延迟绑定和快速失败的Spliterator。
List<E>	subList(int fromIndex, int toIndex)	返回列表中从fromIndex（包括）到toIndex（不包括）之间的部分的视图。
Object[]	toArray()	返回一个数组，其中包含此向量中所有元素的正确顺序。
<T> T[]	toArray(T[] a)	返回一个数组，其中包含此向量中所有元素的正确顺序；返回数组的运行时类型是指定数组的类型。
String	toString()	返回此向量的字符串表示形式，包含每个元素的字符串表示形式。
void	trimToSize()	将此向量的容量修剪为向量的当前大小。

Methods declared in class java.lang.Object

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

Methods declared in interface java.util.Collection

parallelStream, stream, toArray

Methods declared in interface java.util.List

addFirst, addLast, getFirst, getLast, removeFirst, removeLast, reversed, sort

Field Details

elementData

             protected Object[] elementData
            

向量的组件存储在其中的数组缓冲区。向量的容量是此数组缓冲区的长度，至少足够大以包含所有向量的元素。

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

elementCount

             protected int elementCount
            

此Vector对象中有效组件的数量。组件elementData[0]到elementData[elementCount-1]是实际项。

capacityIncrement

             protected int capacityIncrement
            

自动增加向量容量的数量，当其大小大于容量时。如果容量增量小于或等于零，则每次需要增长时向量的容量会加倍。

Constructor Details

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版本起:

1.2

Method Details

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

返回此向量中的组件数。

指定者:

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。更正式地说，仅当此向量包含至少一个元素e使得Objects.equals(o, e)时才返回true。

指定者:

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。

Specified by:

indexOf in interface List<E>

Overrides:

indexOf in class AbstractList<E>

Parameters:

o - element to search for

Returns:

the index of the first occurrence of the specified element in this vector, or -1 if this vector does not contain the element

indexOf

             public int indexOf(Object o, int index)
            

Returns the index of the first occurrence of the specified element in this vector, searching forwards from index, or returns -1 if the element is not found. More formally, returns the lowest index i such that (i >= index && Objects.equals(o, get(i))), or -1 if there is no such index.

Parameters:

o - element to search for

index - index to start searching from

Returns:

the index of the first occurrence of the element in this vector at position index or later in the vector; -1 if the element is not found.

Throws:

IndexOutOfBoundsException - if the specified index is negative

See Also:

• Object.equals(Object)

lastIndexOf

             public int lastIndexOf(Object o)
            

Returns the index of the last occurrence of the specified element in this vector, or -1 if this vector does not contain the element. More formally, returns the highest index i such that Objects.equals(o, get(i)), or -1 if there is no such index.

指定者:

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。

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

此方法在功能上与remove(int)方法（作为List接口的一部分）相同。请注意，remove方法返回存储在指定位置的旧值。

参数:

index - 要移除对象的索引

抛出:

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

insertElementAt

             public void insertElementAt(E obj, int index)
            

在指定index处将指定对象作为组件插入此向量。此向量中索引大于或等于指定index的每个组件都向上移动，索引增加一个单位。

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

此方法在功能上与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)
            

从此向量中删除参数的第一个（索引最低）出现。如果在此向量中找到对象，则向量中索引大于或等于对象索引的每个组件都向下移动，索引减小一个单位。

此方法在功能上与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不包含任何null元素时，这对于确定Vector的长度非常有用。）

指定由：

toArray 在接口 Collection<E>中

指定由：

toArray 在接口 List<E>中

覆盖自：

toArray 在类 AbstractCollection<E>中

类型参数：

T - 数组元素的类型。与<E>相同类型或<E>的超类型。

参数：

a - 要存储Vector元素的数组，如果足够大；否则，为此目的分配相同运行时类型的新数组。

返回：

包含Vector元素的数组

抛出：

ArrayStoreException - 如果a的运行时类型<T>不是此Vector中每个元素的运行时类型<E>的超类型

NullPointerException - 如果给定的数组为null

自：

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 - 如果指定的集合为null

参见:

• AbstractCollection.contains(Object)

addAll

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

将指定集合中的所有元素按照指定集合的迭代器返回的顺序追加到此Vector的末尾。如果在操作进行时修改了指定集合，则此操作的行为是未定义的。（这意味着如果指定集合是此Vector且此Vector非空，则此调用的行为是未定义的。）

指定者:

addAll 在接口 Collection<E>中

指定者:

addAll 在接口 List<E>中

覆盖:

addAll 在类 AbstractCollection<E>中

参数:

c - 要插入到此Vector中的元素

返回值:

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

抛出:

NullPointerException - 如果指定的集合为null

自:

1.2

参见:

• AbstractCollection.add(Object)

removeAll

             public boolean removeAll(Collection<?> c)
            

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

指定者:

removeAll 在接口 Collection<E>中

指定者:

removeAll 在接口 List<E>中

覆盖:

removeAll 在类 AbstractCollection<E>中

参数:

c - 要从Vector中移除的元素集合

返回值:

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

抛出:

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

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

自:

1.2

参见:

• AbstractCollection.remove(Object)
• AbstractCollection.contains(Object)

retainAll

             public boolean retainAll(Collection<?> c)
            

仅保留此Vector中包含在指定集合中的元素。换句话说，从此Vector中移除所有不包含在指定集合中的元素。

指定者:

retainAll 在接口 Collection<E>中

指定者:

retainAll 在接口 List<E>中

覆盖:

retainAll 在类 AbstractCollection<E>中

参数:

c - 要在此Vector中保留的元素集合（所有其他元素将被移除）

返回值:

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

抛出:

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

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

自:

1.2

参见:

• AbstractCollection.remove(Object)
• AbstractCollection.contains(Object)

removeIf

             public boolean removeIf(Predicate<? super E> filter)
            

从接口中复制的描述: Collection

移除此集合中满足给定谓词的所有元素。在迭代过程中抛出的错误或运行时异常将传递给调用者。

指定者:

removeIf 在接口 Collection<E>中

参数:

filter - 一个返回true以便移除元素的谓词

返回值:

true 如果有任何元素被移除

抛出:

NullPointerException - 如果指定的过滤器为null

addAll

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

将指定集合中的所有元素插入到此Vector的指定位置。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。新元素将按照指定集合的迭代器返回的顺序出现在Vector中。

指定者:

addAll 在接口 List<E>中

覆盖:

addAll 在类 AbstractList<E>中

参数:

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

c - 要插入到此Vector中的元素

返回值:

true 如果此Vector由于调用而更改

抛出:

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

NullPointerException - 如果指定的集合为null

自:

1.2

equals

             public boolean equals(Object o)
            

将指定的对象与此Vector进行比较以检查是否相等。如果指定的对象也是一个List，两个List的大小相同，并且两个List中对应的元素对都是相等的，则返回true。（如果Objects.equals(e1, e2)，则两个元素e1和e2是相等的。）换句话说，如果两个List包含相同顺序的相同元素，则定义它们相等。

指定由：

equals 在接口 Collection<E>中

指定由：

equals 在接口 List<E>中

覆盖：

equals 在类 AbstractList<E>中

参数：

o - 用于与此Vector进行比较的对象

返回：

如果指定的对象等于此Vector，则返回true

参见：

• Object.hashCode()
• HashMap

hashCode

             public int hashCode()
            

返回此Vector的哈希码值。

指定由：

hashCode 在接口 Collection<E>中

指定由：

hashCode 在接口 List<E>中

覆盖：

hashCode 在类 AbstractList<E>中

返回：

此列表的哈希码值

参见：

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

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

此方法消除了显式范围操作的需要（通常存在于数组中）。任何期望列表的操作都可以通过对子列表视图而不是整个列表进行操作来用作范围操作。例如，以下习语从列表中删除一系列元素：

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

可以为indexOf和lastIndexOf构造类似的习语，并且Collections类中的所有算法都可以应用于子列表。

如果通过此方法返回的列表在除了通过返回的列表之外的任何方式上对支持列表（即，此列表）进行了结构修改，则此方法返回的列表的语义将变得不明确。（结构修改是那些改变列表大小或以某种方式扰乱列表的操作，以致正在进行的迭代可能产生不正确的结果。）

指定由：

subList 在接口 List<E>中

覆盖：

subList 在类 AbstractList<E>中

参数：

fromIndex - 子列表的低端点（包括）

toIndex - 子列表的高端点（不包括）

返回：

此列表中指定范围的视图

抛出：

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

IllegalArgumentException - 如果端点索引顺序不正确 (fromIndex > toIndex)

removeRange

             protected void removeRange(int fromIndex, int toIndex)
            

从此列表中删除所有索引位于fromIndex（包括）和toIndex（不包括）之间的元素。将任何后续元素向左移（减少其索引）。此调用通过(toIndex - fromIndex)元素缩短列表。（如果toIndex==fromIndex，则此操作无效。）

覆盖：

removeRange 在类 AbstractList<E>中

参数：

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

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

listIterator

             public ListIterator<E> listIterator(int index)
            

返回此列表中元素的列表迭代器（按正确顺序），从列表中指定位置开始。指定的索引表示通过对next的初始调用将返回的第一个元素。对previous的初始调用将返回指定索引减一的元素。

返回的列表迭代器是fail-fast的。

指定由：

listIterator 在接口 List<E>中

覆盖：

listIterator 在类 AbstractList<E>中

参数：

index - 要从列表迭代器返回的第一个元素的索引（通过调用next）

返回：

从列表中指定位置开始的元素的列表迭代器（按正确顺序）

抛出：

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

listIterator

             public ListIterator<E> listIterator()
            

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

返回的列表迭代器是fail-fast的。

指定由：

listIterator 在接口 List<E>中

覆盖：

listIterator 在类 AbstractList<E>中

返回：

从列表中按正确顺序返回元素的列表迭代器

参见：

• listIterator(int)

iterator

             public Iterator<E> iterator()
            

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

返回的迭代器是fail-fast的。

指定由：

iterator 在接口 Collection<E>中

指定由：

iterator 在接口 Iterable<E>中

指定由：

iterator 在接口 List<E>中

覆盖：

iterator 在类 AbstractList<E>中

返回：

按正确顺序返回此列表中元素的迭代器

forEach

             public void forEach(Consumer<? super E> action)
            

从接口复制的描述： Iterable

对Iterable的每个元素执行给定操作，直到所有元素都已处理或操作引发异常。如果指定了顺序，则按迭代顺序执行操作。操作引发的异常将传递给调用者。

如果操作执行会修改元素的底层源的副作用，则此方法的行为是不确定的，除非覆盖类已指定并发修改策略。

指定由：

forEach 在接口 Iterable<E>

参数：

action - 要对每个元素执行的操作

抛出：

NullPointerException - 如果指定的操作为null

replaceAll

             public void replaceAll(UnaryOperator<E> operator)
            

从接口复制的描述： List

用该运算符应用于该元素的结果替换此列表的每个元素。运算符引发的错误或运行时异常将被传递给调用者。

指定由：

replaceAll 在接口 List<E>

参数：

operator - 要应用于每个元素的运算符

抛出：

NullPointerException - 如果指定的运算符为null，或者如果运算符的结果为null值且此列表不允许null元素（可选）

spliterator

             public Spliterator<E> spliterator()
            

在此列表中的元素上创建一个延迟绑定和快速失败Spliterator。

Spliterator报告Spliterator.SIZED，Spliterator.SUBSIZED和Spliterator.ORDERED。重写实现应记录其他特征值的报告。

指定由：

spliterator 在接口 Collection<E>

指定由：

spliterator 在接口 Iterable<E>

指定由：

spliterator 在接口 List<E>

返回：

此列表中的元素的Spliterator

自1.8起：

1.8