java.lang.Object
|---java.util.AbstractCollection<E&
|---|---java.util.AbstractList<E&
|---|---|---java.util.Vector<E&
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable
Vector 类实现了一个可增长的对象数组。 像数组一样，它包含可以使用整数索引访问的组件。 但是，Vector 的大小可以根据需要增加或缩小，以适应在创建 Vector 后添加和删除项目。
每个向量都试图通过维护容量和容量增量来优化存储管理。 容量总是至少与向量大小一样大； 它通常更大，因为随着组件被添加到向量中，向量的存储以块的形式增加容量增量的大小。 应用程序可以在插入大量组件之前增加向量的容量； 这减少了增量重新分配的数量。
此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：如果在创建迭代器后的任何时间对向量进行结构修改，除了通过迭代器自己的 ListIterator#remove() 或 ListIterator#add(Object) 之外的任何方式 方法，迭代器将抛出 ConcurrentModificationException。 因此，面对并发修改，迭代器快速而干净地失败，而不是在未来不确定的时间冒着任意的、非确定性的行为。 elements 方法返回的枚举不是快速失败的。
请注意，不能保证迭代器的快速失败行为，因为一般来说，在存在不同步的并发修改的情况下，不可能做出任何硬保证。 快速失败的迭代器会尽最大努力抛出 ConcurrentModificationException。 因此，编写一个依赖于这个异常的正确性的程序是错误的：迭代器的快速失败行为应该只用于检测错误。
从 Java 2 平台 v1.2 开始，该类被改进为实现 List 接口，使其成为 Java Collections Framework 的成员。 与新的集合实现不同，Vector 是同步的。 如果不需要线程安全实现，建议使用 ArrayList 代替 Vector。
| 修饰符和类型 | 字段 | 描述 |
|---|---|---|
| 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) | 返回指定索引处的组件。 |
| EnumerationE | 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) | 返回此向量中第一次出现的指定元素的索引，从索引向前搜索，如果未找到该元素，则返回 -1。 |
| void | insertElementAt(E obj, int index) | 将指定对象作为组件插入此向量中指定索引处。 |
| boolean | isEmpty() | 测试此向量是否没有分量。 |
| IteratorE | iterator() | 以正确的顺序返回此列表中元素的迭代器。 |
| E | lastElement() | 返回向量的最后一个分量。 |
| int | lastIndexOf(Object o) | 返回此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则返回 -1。 |
| int | lastIndexOf(Object o, int index) | 返回此向量中指定元素最后一次出现的索引，从索引向后搜索，如果未找到该元素，则返回 -1。 |
| ListIteratorE | listIterator() | 返回此列表中元素的列表迭代器（以正确的顺序）。 |
| ListIteratorE | listIterator(int index) | 返回此列表中元素的列表迭代器（以正确的顺序），从列表中的指定位置开始。 |
| 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) | 从此列表中删除索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。 |
| void | replaceAll(UnaryOperatorE operator) | 将此列表的每个元素替换为将运算符应用于该元素的结果。 |
| boolean | retainAll(Collection<?> c) | 仅保留此 Vector 中包含在指定 Collection 中的元素。 |
| E | set(int index, E element) | 将此 Vector 中指定位置的元素替换为指定元素。 |
| void | setElementAt(E obj, int index) | 将此向量的指定索引处的组件设置为指定对象。 |
| void | setSize(int newSize) | 设置此向量的大小。 |
| int | size() | 返回此向量中的分量数。 |
| void | sort(Comparator<? super E> c) | 根据指定 Comparator 产生的顺序对该列表进行排序。 |
| SpliteratorE | spliterator() | 在此列表中的元素上创建一个后期绑定和快速失败的拆分器。 |
| ListE | subList(int fromIndex, int toIndex) | 返回此 List 在 fromIndex（包括）和 toIndex（不包括）之间部分的视图。 |
| Object[] | toArray() | 以正确的顺序返回包含此 Vector 中所有元素的数组。 |
| <T> T[] | toArray(T[] a) | 以正确的顺序返回包含此 Vector 中所有元素的数组； 返回数组的运行时类型是指定数组的运行时类型。 |
| String | toString() | 返回此 Vector 的字符串表示形式，其中包含每个元素的字符串表示形式。 |
| void | trimToSize() | 将此向量的容量修剪为向量的当前大小。 |
| 从接口 java.util.Collection 继承的方法 |
|---|
| parallelStream, stream |
| 从类 java.lang.Object 继承的方法 |
|---|
| finalize, getClass, notify, notifyAll, wait, wait, wait |
protected int capacityIncrement
当向量的大小变得大于其容量时，向量的容量自动增加的量。 如果容量增量小于或等于零，则每次需要增长时，向量的容量都会增加一倍。
protected int elementCount
此 Vector 对象中的有效组件数。 组件 elementData[0] 到 elementData[elementCount-1] 是实际项目。
protected Object[] elementData
存储向量分量的数组缓冲区。 向量的容量是这个数组缓冲区的长度，并且至少大到足以包含所有向量的元素。
Vector 中最后一个元素之后的任何数组元素都为空。
public Vector(int initialCapacity, int capacityIncrement)
构造一个具有指定初始容量和容量增量的空向量。
参数：
| 参数名称 | 参数描述 |
|---|---|
| initialCapacity | 向量的初始容量 |
| capacityIncrement | 向量溢出时容量增加的量 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果指定的初始容量为负 |
public Vector(int initialCapacity)
构造一个具有指定初始容量且容量增量为零的空向量。
参数：
| 参数名称 | 参数描述 |
|---|---|
| initialCapacity | 向量的初始容量 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IllegalArgumentException | 如果指定的初始容量为负 |
public Vector()
构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
public Vector(Collection<? extends E> c)
按照集合的迭代器返回的顺序构造一个包含指定集合元素的向量。
参数：
| 参数名称 | 参数描述 |
|---|---|
| c | 将其元素放入此向量的集合 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果指定的集合为空 |
public void copyInto(Object[] anArray)
将此向量的分量复制到指定的数组中。 此向量中索引 k 处的项目被复制到 anArray 的组件 k 中。
参数：
| 参数名称 | 参数描述 |
|---|---|
| anArray | 组件被复制到的数组 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果给定数组为空 |
| IndexOutOfBoundsException | 如果指定的数组不足以容纳此向量的所有组件 |
| ArrayStoreException | 如果此向量的组件不是可以存储在指定数组中的运行时类型 |
public void trimToSize()
将此向量的容量修剪为向量的当前大小。 如果此向量的容量大于其当前大小，则通过将其内部数据数组（保存在字段 elementData 中）替换为较小的数组，将容量更改为等于大小。 应用程序可以使用此操作来最小化向量的存储。
public void ensureCapacity(int minCapacity)
如有必要，增加此向量的容量，以确保它至少可以容纳最小容量参数指定的分量数。
如果该向量的当前容量小于 minCapacity，则通过将其内部数据数组（保存在字段 elementData 中）替换为更大的数组来增加其容量。 新数据数组的大小将是旧大小加上容量增量，除非容量增量的值小于或等于零，这种情况下新容量将是旧容量的两倍； 但如果这个新大小仍然小于 minCapacity，那么新容量将为 minCapacity。
参数：
| 参数名称 | 参数描述 |
|---|---|
| minCapacity | 所需的最小容量 |
public void setSize(int newSize)
设置此向量的大小。 如果新大小大于当前大小，则将新的空项添加到向量的末尾。 如果新大小小于当前大小，则索引 newSize 和更大的所有组件都将被丢弃。
参数：
| 参数名称 | 参数描述 |
|---|---|
| newSize | 这个向量的新大小 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果新大小为负 |
public int capacity()
返回此向量的当前容量。
返回:
当前容量（其内部数据数组的长度，保存在该向量的字段 elementData 中）
public int size()
返回此向量中的分量数。
指定者：
接口 CollectionE 中的大小
指定者：
接口 ListE 中的大小
指定者：
AbstractCollectionE 类中的大小
返回:
此向量中的组件数
public boolean isEmpty()
测试此向量是否没有分量。
指定者：
接口 CollectionE 中的 isEmpty
指定者：
接口 ListE 中的 isEmpty
覆盖：
类 AbstractCollectionE 中的 isEmpty
返回:
当且仅当此向量没有分量时，即其大小为零时才为 true； 否则为 false。
public EnumerationE elements()
返回此向量的组件的枚举。 返回的 Enumeration 对象将生成此向量中的所有项目。 生成的第一个项目是索引 0 处的项目，然后是索引 1 处的项目，依此类推。
返回:
此向量的组件的枚举
public boolean contains(Object o)
如果此向量包含指定元素，则返回 true。 更正式地说，当且仅当此向量包含至少一个元素 e 满足 (o==null ? e==null : o.equals(e)) 时才返回 true。
指定者：
包含在接口 CollectionE 中
指定者：
包含在接口 ListE 中
覆盖：
包含在类 AbstractCollectionE 中
参数：
| 参数名称 | 参数描述 |
|---|---|
| o | 要测试其在此向量中的存在的元素 |
返回:
如果此向量包含指定元素，则为 true
public int indexOf(Object o)
返回此向量中指定元素第一次出现的索引，如果此向量不包含该元素，则返回 -1。 更正式地说，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i，如果没有这样的索引，则返回 -1。
指定者：
接口 ListE 中的 indexOf
覆盖：
AbstractListE 类中的 indexOf
参数：
| 参数名称 | 参数描述 |
|---|---|
| o | 要搜索的元素 |
返回:
此向量中指定元素第一次出现的索引，如果此向量不包含该元素，则为 -1
public int indexOf(Object o, int index)
返回此向量中第一次出现的指定元素的索引，从索引向前搜索，如果未找到该元素，则返回 -1。 更正式地，返回最低索引 i 使得 (i >= index && (o==null ? get(i)==null : o.equals(get(i))))，如果不存在则返回 -1 指数。
参数：
| 参数名称 | 参数描述 |
|---|---|
| o | 要搜索的元素 |
| index | 开始搜索的索引 |
返回:
此向量中第一次出现的元素在位置 index 或向量后面的索引； -1 如果未找到该元素。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IndexOutOfBoundsException | 如果指定的索引为负 |
public int lastIndexOf(Object o)
返回此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则返回 -1。 更正式地说，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i，如果没有这样的索引，则返回 -1。
指定者：
接口 ListE 中的 lastIndexOf
覆盖：
类 AbstractListE 中的 lastIndexOf
参数：
| 参数名称 | 参数描述 |
|---|---|
| o | 要搜索的元素 |
返回:
此向量中指定元素的最后一次出现的索引，如果此向量不包含该元素，则为 -1
public int lastIndexOf(Object o, int index)
返回此向量中指定元素最后一次出现的索引，从索引向后搜索，如果未找到该元素，则返回 -1。 更正式地，返回最高索引 i 使得 (i <= index && (o==null ? get(i)==null : o.equals(get(i))))，如果不存在则返回 -1 指数。
参数：
| 参数名称 | 参数描述 |
|---|---|
| o | 要搜索的元素 |
| index | 开始向后搜索的索引 |
返回:
在该向量中小于或等于 index 的位置上最后一次出现的元素的索引； -1 如果未找到该元素。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IndexOutOfBoundsException | 如果指定的索引大于或等于此向量的当前大小 |
public E elementAt(int index)
返回指定索引处的组件。
此方法在功能上与 get(int) 方法（它是 List 接口的一部分）相同。
参数：
| 参数名称 | 参数描述 |
|---|---|
| index | 该向量的索引 |
返回:
指定索引处的组件
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index >= size()) |
public E firstElement()
返回此向量的第一个组件（索引 0 处的项目）。
返回:
这个向量的第一个分量
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NoSuchElementException | 如果这个向量没有分量 |
public E lastElement()
返回向量的最后一个分量。
返回:
向量的最后一个分量，即索引 size() - 1 处的分量。
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NoSuchElementException | 如果这个向量是空的 |
public void setElementAt(E obj, int index)
将此向量的指定索引处的组件设置为指定对象。 该位置的前一个组件被丢弃。
索引必须是大于或等于 0 且小于向量当前大小的值。
此方法在功能上与 set(int, E) 方法（它是 List 接口的一部分）相同。 请注意，set 方法颠倒了参数的顺序，以更接近地匹配数组的使用。 另请注意，set 方法返回存储在指定位置的旧值。
参数：
| 参数名称 | 参数描述 |
|---|---|
| obj | 组件要设置成什么 |
| index | 指定索引 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index >= size()) |
public void removeElementAt(int index)
删除指定索引处的组件。 此向量中具有大于或等于指定索引的索引的每个分量都向下移动以具有比其先前具有的值小一的索引。 该向量的大小减 1。
索引必须是大于或等于 0 且小于向量当前大小的值。
此方法在功能上与 remove(int) 方法（它是 List 接口的一部分）相同。 请注意，remove 方法返回存储在指定位置的旧值。
参数：
| 参数名称 | 参数描述 |
|---|---|
| index | 要删除的对象的索引 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index >= size()) |
public void insertElementAt(E obj, int index)
将指定对象作为组件插入此向量中指定索引处。 此向量中具有大于或等于指定索引的索引的每个分量都向上移动以具有比其先前具有的值大一的索引。
索引必须是大于或等于 0 且小于或等于向量当前大小的值。 （如果索引等于向量的当前大小，则将新元素附加到向量。）
此方法在功能上与 add(int, E) 方法（它是 List 接口的一部分）相同。 请注意，add 方法颠倒了参数的顺序，以更紧密地匹配数组的使用。
参数：
| 参数名称 | 参数描述 |
|---|---|
| obj | 要插入的组件 |
| index | 在哪里插入新组件 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index > size()) |
public void addElement(E obj)
将指定的组件添加到此向量的末尾，将其大小增加一。 如果该向量的大小变得大于其容量，则该向量的容量会增加。
此方法在功能上与 add(E) 方法（它是 List 接口的一部分）相同。
参数：
| 参数名称 | 参数描述 |
|---|---|
| obj | 要添加的组件 |
public boolean removeElement(Object obj)
从此向量中删除参数的第一个（最低索引）出现。 如果在该向量中找到对象，则向量中具有大于或等于对象索引的索引的每个分量将向下移动以具有比其先前具有的值小一的索引。
此方法在功能上与 remove(java.lang.Object) 方法（它是 List 接口的一部分）相同。
参数：
| 参数名称 | 参数描述 |
|---|---|
| obj | 要移除的组件 |
返回:
如果参数是这个向量的一个组成部分，则为 true； 否则为 false。
public void removeAllElements()
从此向量中删除所有组件并将其大小设置为零。
此方法在功能上与 clear() 方法（它是 List 接口的一部分）相同。
public Object clone()
返回此向量的克隆。 该副本将包含对内部数据数组的克隆的引用，而不是对该 Vector 对象的原始内部数据数组的引用。
覆盖：
在类 Object 中克隆
返回:
该载体的克隆
public Object[] toArray()
以正确的顺序返回包含此 Vector 中所有元素的数组。
指定者：
接口 CollectionE 中的 toArray
指定者：
接口 ListE 中的 toArray
覆盖：
AbstractCollectionE 类中的 toArray
返回:
包含此集合中所有元素的数组
public <T> T[] toArray(T[] a)
以正确的顺序返回包含此 Vector 中所有元素的数组； 返回数组的运行时类型是指定数组的运行时类型。 如果 Vector 适合指定的数组，则在其中返回。 否则，将使用指定数组的运行时类型和此 Vector 的大小分配一个新数组。
如果向量适合指定的数组并有剩余空间（即，数组的元素多于向量），则数组中紧跟向量末尾的元素设置为空。 （仅当调用者知道 Vector 不包含任何 null 元素时，这在确定 Vector 的长度时才有用。）
指定者：
接口 CollectionE 中的 toArray
指定者：
接口 ListE 中的 toArray
覆盖：
AbstractCollectionE 类中的 toArray
类型参数：
| 类型参数名称 | 类型参数描述 |
|---|---|
| T | 包含集合的数组的运行时类型 |
参数:
| 参数名称 | 参数描述 |
|---|---|
| a | 将存储 Vector 元素的数组（如果它足够大）； 否则，将为此目的分配相同运行时类型的新数组。 |
返回:
包含 Vector 元素的数组
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayStoreException | 如果 a 的运行时类型不是此 Vector 中每个元素的运行时类型的超类型 |
| NullPointerException | 如果给定数组为空 |
public E get(int index)
返回此 Vector 中指定位置的元素。
指定者：
进入接口 ListE
指定者：
进入类 AbstractListE
参数：
| 参数名称 | 参数描述 |
|---|---|
| index | 要返回的元素的索引 |
返回:
指定索引处的对象
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index >= size()) |
public E set(int index, E element)
将此 Vector 中指定位置的元素替换为指定元素。
指定者：
在接口 ListE 中设置
覆盖：
在类 AbstractListE 中设置
参数：
| 参数名称 | 参数描述 |
|---|---|
| index | 要替换的元素的索引 |
| element | 要存储在指定位置的元素 |
返回:
先前在指定位置的元素
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index >= size()) |
public boolean add(E e)
将指定元素附加到此 Vector 的末尾。
指定者：
添加接口CollectionE
指定者：
添加接口ListE
覆盖：
添加类 AbstractListE
参数：
| 参数名称 | 参数描述 |
|---|---|
| e | 要附加到此 Vector 的元素 |
返回:
true（由 Collection#add 指定）
public boolean remove(Object o)
删除此 Vector 中指定元素的第一个匹配项 如果 Vector 不包含该元素，则它不变。 更正式地说，删除具有最低索引 i 的元素，使得 (o==null ? get(i)==null : o.equals(get(i))) （如果存在这样的元素）。
指定者：
在接口 CollectionE 中删除
指定者：
在接口 ListE 中删除
覆盖：
在类 AbstractCollectionE 中删除
参数：
| 参数名称 | 参数描述 |
|---|---|
| o | 要从此向量中删除的元素（如果存在） |
返回:
如果 Vector 包含指定元素，则为 true
public void add(int index, E element)
在此 Vector 中的指定位置插入指定元素。 将当前位于该位置的元素（如果有）和任何后续元素向右移动（将其索引加一）。
指定者：
添加接口ListE
覆盖：
添加类 AbstractListE
参数：
| 参数名称 | 参数描述 |
|---|---|
| index | 要插入指定元素的索引 |
| element | 要插入的元素 |
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index > size()) |
public E remove(int index)
移除此 Vector 中指定位置的元素。 将任何后续元素向左移动（从它们的索引中减去 1）。 返回从 Vector 中删除的元素。
指定者：
在接口 ListE 中删除
覆盖：
在类 AbstractListE 中删除
参数：
| 参数名称 | 参数描述 |
|---|---|
| index | 要删除的元素的索引 |
返回:
被移除的元素
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index >= size()) |
public void clear()
从此 Vector 中删除所有元素。 此调用返回后 Vector 将为空（除非它引发异常）。
指定者：
在接口 CollectionE 中清除
指定者：
在接口 ListE 中清除
覆盖：
在类 AbstractListE 中清除
public boolean containsAll(Collection<?> c)
如果此 Vector 包含指定 Collection 中的所有元素，则返回 true。
指定者：
接口 CollectionE 中的 containsAll
指定者：
接口 ListE 中的 containsAll
覆盖：
类 AbstractCollectionE 中的 containsAll
参数：
| 参数名称 | 参数描述 |
|---|---|
| c | 一个集合，其元素将被测试是否包含在此 Vector 中 |
返回:
如果此 Vector 包含指定集合中的所有元素，则为 true
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果指定的集合为空 |
public boolean addAll(Collection<? extends E> c)
将指定 Collection 中的所有元素附加到此 Vector 的末尾，按照指定 Collection 的 Iterator 返回的顺序。 如果在操作正在进行时修改了指定的集合，则此操作的行为是未定义的。 （这意味着如果指定的 Collection 是这个 Vector，并且这个 Vector 是非空的，那么这个调用的行为是未定义的。）
指定者：
接口 CollectionE 中的 addAll
指定者：
接口 ListE 中的 addAll
覆盖：
类 AbstractCollectionE 中的 addAll
参数：
| 参数名称 | 参数描述 |
|---|---|
| c | 要插入此 Vector 的元素 |
返回:
如果此 Vector 由于调用而更改，则为 true
Throws:
| Throw名称 | Throw描述 |
|---|---|
| NullPointerException | 如果指定的集合为空 |
public boolean removeAll(Collection<?> c)
从此 Vector 中删除包含在指定 Collection 中的所有元素。
指定者：
接口 CollectionE 中的 removeAll
指定者：
接口 ListE 中的 removeAll
覆盖：
类 AbstractCollectionE 中的 removeAll
参数：
| 参数名称 | 参数描述 |
|---|---|
| c | 要从 Vector 中删除的元素集合 |
返回:
如果此 Vector 由于调用而更改，则为 true
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果此向量中的一个或多个元素的类型与指定的集合不兼容（可选） |
| NullPointerException | 如果此向量包含一个或多个空元素并且指定的集合不支持空元素（可选），或者指定的集合为空 |
public boolean retainAll(Collection<?> c)
仅保留此 Vector 中包含在指定 Collection 中的元素。 换句话说，从这个 Vector 中移除所有不包含在指定 Collection 中的元素。
指定者：
接口CollectionE中的retainAll
指定者：
接口 ListE 中的 retainAll
覆盖：
类 AbstractCollectionE 中的 retainAll
参数：
| 参数名称 | 参数描述 |
|---|---|
| c | 要保留在此 Vector 中的元素集合（删除所有其他元素） |
返回:
如果此 Vector 由于调用而更改，则为 true
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ClassCastException | 如果此向量中的一个或多个元素的类型与指定的集合不兼容（可选） |
| NullPointerException | 如果此向量包含一个或多个空元素并且指定的集合不支持空元素（可选），或者指定的集合为空 |
public boolean addAll(int index, Collection<? extends E> c)
将指定 Collection 中的所有元素插入到此 Vector 的指定位置。 将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。 新元素将按照指定 Collection 的迭代器返回的顺序出现在 Vector 中。
指定者：
接口 ListE 中的 addAll
覆盖：
类 AbstractListE 中的 addAll
参数：
| 参数名称 | 参数描述 |
|---|---|
| index | 插入指定集合中第一个元素的索引 |
| c | 要插入此 Vector 的元素 |
返回:
如果此 Vector 由于调用而更改，则为 true
Throws:
| Throw名称 | Throw描述 |
|---|---|
| ArrayIndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index > size()) |
| NullPointerException | 如果指定的集合为空 |
public boolean equals(Object o)
比较指定的 Object 与此 Vector 是否相等。 当且仅当指定的 Object 也是一个 List 时返回 true，两个 List 具有相同的大小，并且两个 List 中所有对应的元素对都相等。 （如果 (e1==null ? e2==null : e1.equals(e2)) 两个元素 e1 和 e2 相等。）换句话说，如果两个 List 以相同的顺序包含相同的元素，则它们被定义为相等 .
指定者：
接口 CollectionE 中的等于
指定者：
接口 ListE 中的等于
覆盖：
类 AbstractListE 中的等于
参数：
| 参数名称 | 参数描述 |
|---|---|
| o | 要与此向量比较相等的对象 |
返回:
如果指定的 Object 等于此 Vector，则为 true
public int hashCode()
返回此 Vector 的哈希码值。
指定者：
接口 CollectionE 中的 hashCode
指定者：
接口 ListE 中的 hashCode
覆盖：
AbstractListE 类中的 hashCode
返回:
此列表的哈希码值
public String toString()
返回此 Vector 的字符串表示形式，其中包含每个元素的字符串表示形式。
覆盖：
类 AbstractCollectionE 中的 toString
返回:
此集合的字符串表示形式
public ListE subList(int fromIndex, int toIndex)
返回此 List 在 fromIndex（包括）和 toIndex（不包括）之间部分的视图。 （如果 fromIndex 和 toIndex 相等，则返回的 List 为空。）返回的 List 由该 List 支持，因此返回的 List 中的更改会反映在该 List 中，反之亦然。 返回的 List 支持此 List 支持的所有可选 List 操作。
这种方法消除了显式范围操作的需要（通常存在于数组中的那种）。 通过对 subList 视图而不是整个 List 进行操作，任何需要 List 的操作都可以用作范围操作。 例如，以下习惯用法从 List 中删除一系列元素：
list.subList(from, to).clear();
可以为 indexOf 和 lastIndexOf 构造类似的习语，并且 Collections 类中的所有算法都可以应用于子列表。
如果后备列表（即此列表）以任何方式而不是通过返回的列表进行结构修改，则此方法返回的列表的语义变得未定义。 （结构修改是那些改变列表大小的修改，或者以其他方式扰乱它，使得正在进行的迭代可能会产生不正确的结果。）
指定者：
接口 ListE 中的子列表
覆盖：
AbstractListE 类中的子列表
参数：
| 参数名称 | 参数描述 |
|---|---|
| fromIndex | subList 的低端点（包括） |
| toIndex | subList 的高端（不包括） |
返回:
此列表中指定范围的视图
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IndexOutOfBoundsException | 如果端点索引值超出范围（fromIndex < 0 || toIndex > size） |
| IllegalArgumentException | 如果端点索引乱序（fromIndex > toIndex） |
protected void removeRange(int fromIndex, int toIndex)
从此列表中删除索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。 将任何后续元素向左移动（减少它们的索引）。 此调用通过 (toIndex - fromIndex) 元素缩短列表。 （如果toIndex==fromIndex，则此操作无效。）
覆盖：
AbstractListE 类中的 removeRange
参数：
| 参数名称 | 参数描述 |
|---|---|
| fromIndex | 要删除的第一个元素的索引 |
| toIndex | 要删除的最后一个元素之后的索引 |
public ListIteratorE listIterator(int index)
返回此列表中元素的列表迭代器（以正确的顺序），从列表中的指定位置开始。 指定的索引指示初始调用 ListIterator#next 将返回的第一个元素。 对 ListIterator#previous 的初始调用将返回具有指定索引减一的元素。
返回的列表迭代器是快速失败的。
指定者：
接口 ListE 中的 listIterator
覆盖：
AbstractListE 类中的 listIterator
参数：
| 参数名称 | 参数描述 |
|---|---|
| index | 要从列表迭代器返回的第一个元素的索引（通过调用 ListIterator#next） |
返回:
此列表中元素的列表迭代器（按正确顺序），从列表中的指定位置开始
Throws:
| Throw名称 | Throw描述 |
|---|---|
| IndexOutOfBoundsException | 如果索引超出范围 (index < 0 || index > size()) |
public ListIteratorE listIterator()
返回此列表中元素的列表迭代器（以正确的顺序）。
返回的列表迭代器是快速失败的。
指定者：
接口 ListE 中的 listIterator
覆盖：
AbstractListE 类中的 listIterator
返回:
此列表中元素的列表迭代器（按正确顺序）
public IteratorE iterator()
以正确的顺序返回此列表中元素的迭代器。
返回的迭代器是快速失败的。
指定者：
接口 CollectionE 中的迭代器
指定者：
接口 IterableE 中的迭代器
指定者：
接口 ListE 中的迭代器
覆盖：
AbstractListE 类中的迭代器
返回:
以正确顺序遍历此列表中的元素的迭代器
public void forEach(Consumer<? super E> action)
从接口复制的描述：Iterable
对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。 除非实现类另有规定，否则按迭代顺序执行操作（如果指定了迭代顺序）。 操作引发的异常将转发给调用者。
指定者：
接口 IterableE 中的 forEach
参数：
| 参数名称 | 参数描述 |
|---|---|
| action | 为每个元素执行的操作 |
public boolean removeIf(Predicate<? super E> filter)
从接口复制的描述：集合
删除此集合中满足给定谓词的所有元素。 在迭代期间或由谓词引发的错误或运行时异常将转发给调用者。
指定者：
接口 CollectionE 中的 removeIf
参数：
| 参数名称 | 参数描述 |
|---|---|
| filter | 对于要删除的元素返回 true 的谓词 |
返回:
如果删除了任何元素，则为 true
public void replaceAll(UnaryOperatorE operator)
从接口复制的描述：列表
将此列表的每个元素替换为将运算符应用于该元素的结果。 操作员抛出的错误或运行时异常被转发给调用者。
指定者：
接口 ListE 中的 replaceAll
参数：
| 参数名称 | 参数描述 |
|---|---|
| operator | 应用于每个元素的运算符 |
public void sort(Comparator<? super E> c)
从接口复制的描述：列表
根据指定 Comparator 产生的顺序对该列表进行排序。
此列表中的所有元素必须使用指定的比较器进行相互比较（即 c.compare(e1, e2) 不得为列表中的任何元素 e1 和 e2 抛出 ClassCastException）。
如果指定的比较器为空，则此列表中的所有元素都必须实现 Comparable 接口，并且应使用元素的 Comparable。
此列表必须是可修改的，但不需要调整大小。
指定者：
在接口 ListE 中排序
参数：
| 参数名称 | 参数描述 |
|---|---|
| c | Comparator 用于比较列表元素。 空值表示应该使用元素的 Comparable |
public SpliteratorE spliterator()
在此列表中的元素上创建一个后期绑定和快速失败的拆分器。
Spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED 和 Spliterator#ORDERED。 覆盖实现应记录附加特征值的报告。
指定者：
接口 CollectionE 中的分离器
指定者：
接口 IterableE 中的分离器
指定者：
接口 ListE 中的分离器
返回:
此列表中元素的拆分器
备案信息： 粤ICP备15087711号-2
Copyright © 2008-2024 啊嘎哇在线工具箱 All Rights.
本站所有资料来源于网络，版权归原作者所有，仅作学习交流使用，如不慎侵犯了您的权利，请联系我们。