鸿蒙OS Vector

Vector

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。

字段摘要

构造函数摘要

方法总结

字段详细信息

capacityIncrement

protected int capacityIncrement

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

elementCount

protected int elementCount

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

elementData

protected Object[] elementData

存储向量分量的数组缓冲区。 向量的容量是这个数组缓冲区的长度，并且至少大到足以包含所有向量的元素。

Vector 中最后一个元素之后的任何数组元素都为空。

构造函数详细信息

Vector

public Vector(int initialCapacity, int capacityIncrement)

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

参数：

Throws:

Vector

public Vector(int initialCapacity)

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

参数：

Throws:

Vector

public Vector()

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

Vector

public Vector(Collection<? extends E> c)

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

参数：

Throws:

方法详情

copyInto

public void copyInto(Object[] anArray)

将此向量的分量复制到指定的数组中。 此向量中索引 k 处的项目被复制到 anArray 的组件 k 中。

参数：

Throws:

trimToSize

public void trimToSize()

将此向量的容量修剪为向量的当前大小。 如果此向量的容量大于其当前大小，则通过将其内部数据数组（保存在字段 elementData 中）替换为较小的数组，将容量更改为等于大小。 应用程序可以使用此操作来最小化向量的存储。

ensureCapacity

public void ensureCapacity(int minCapacity)

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

如果该向量的当前容量小于 minCapacity，则通过将其内部数据数组（保存在字段 elementData 中）替换为更大的数组来增加其容量。 新数据数组的大小将是旧大小加上容量增量，除非容量增量的值小于或等于零，这种情况下新容量将是旧容量的两倍； 但如果这个新大小仍然小于 minCapacity，那么新容量将为 minCapacity。

参数：

setSize

public void setSize(int newSize)

设置此向量的大小。 如果新大小大于当前大小，则将新的空项添加到向量的末尾。 如果新大小小于当前大小，则索引 newSize 和更大的所有组件都将被丢弃。

参数：

Throws:

capacity

public int capacity()

返回此向量的当前容量。

返回:

当前容量（其内部数据数组的长度，保存在该向量的字段 elementData 中）

size

public int size()

返回此向量中的分量数。

指定者：

接口 CollectionE 中的大小

指定者：

接口 ListE 中的大小

指定者：

AbstractCollectionE 类中的大小

返回:

此向量中的组件数

isEmpty

public boolean isEmpty()

测试此向量是否没有分量。

指定者：

接口 CollectionE 中的 isEmpty

指定者：

接口 ListE 中的 isEmpty

覆盖：

类 AbstractCollectionE 中的 isEmpty

返回:

当且仅当此向量没有分量时，即其大小为零时才为 true； 否则为 false。

elements

public EnumerationE elements()

返回此向量的组件的枚举。 返回的 Enumeration 对象将生成此向量中的所有项目。 生成的第一个项目是索引 0 处的项目，然后是索引 1 处的项目，依此类推。

返回:

此向量的组件的枚举

contains

public boolean contains(Object o)

如果此向量包含指定元素，则返回 true。 更正式地说，当且仅当此向量包含至少一个元素 e 满足 (o==null ? e==null : o.equals(e)) 时才返回 true。

指定者：

包含在接口 CollectionE 中

指定者：

包含在接口 ListE 中

覆盖：

包含在类 AbstractCollectionE 中

参数：

返回:

如果此向量包含指定元素，则为 true

indexOf

public int indexOf(Object o)

返回此向量中指定元素第一次出现的索引，如果此向量不包含该元素，则返回 -1。 更正式地说，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i，如果没有这样的索引，则返回 -1。

指定者：

接口 ListE 中的 indexOf

覆盖：

AbstractListE 类中的 indexOf

参数：

返回:

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

indexOf

public int indexOf(Object o, int index)

返回此向量中第一次出现的指定元素的索引，从索引向前搜索，如果未找到该元素，则返回 -1。 更正式地，返回最低索引 i 使得 (i >= index && (o==null ? get(i)==null : o.equals(get(i))))，如果不存在则返回 -1 指数。

参数：

返回:

此向量中第一次出现的元素在位置 index 或向量后面的索引； -1 如果未找到该元素。

Throws:

lastIndexOf

public int lastIndexOf(Object o)

返回此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则返回 -1。 更正式地说，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i，如果没有这样的索引，则返回 -1。

指定者：

接口 ListE 中的 lastIndexOf

覆盖：

类 AbstractListE 中的 lastIndexOf

参数：

返回:

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

lastIndexOf

public int lastIndexOf(Object o, int index)

返回此向量中指定元素最后一次出现的索引，从索引向后搜索，如果未找到该元素，则返回 -1。 更正式地，返回最高索引 i 使得 (i <= index && (o==null ? get(i)==null : o.equals(get(i))))，如果不存在则返回 -1 指数。

参数：

返回:

在该向量中小于或等于 index 的位置上最后一次出现的元素的索引； -1 如果未找到该元素。

Throws:

elementAt

public E elementAt(int index)

返回指定索引处的组件。

此方法在功能上与 get(int) 方法（它是 List 接口的一部分）相同。

参数：

返回:

指定索引处的组件

Throws:

firstElement

public E firstElement()

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

返回:

这个向量的第一个分量

Throws:

lastElement

public E lastElement()

返回向量的最后一个分量。

返回:

向量的最后一个分量，即索引 size() – 1 处的分量。

Throws:

setElementAt

public void setElementAt(E obj, int index)

将此向量的指定索引处的组件设置为指定对象。 该位置的前一个组件被丢弃。

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

此方法在功能上与 set(int, E) 方法（它是 List 接口的一部分）相同。 请注意，set 方法颠倒了参数的顺序，以更接近地匹配数组的使用。 另请注意，set 方法返回存储在指定位置的旧值。

参数：

Throws:

removeElementAt

public void removeElementAt(int index)

删除指定索引处的组件。 此向量中具有大于或等于指定索引的索引的每个分量都向下移动以具有比其先前具有的值小一的索引。 该向量的大小减 1。

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

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

参数：

Throws:

insertElementAt

public void insertElementAt(E obj, int index)

将指定对象作为组件插入此向量中指定索引处。 此向量中具有大于或等于指定索引的索引的每个分量都向上移动以具有比其先前具有的值大一的索引。

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

此方法在功能上与 add(int, E) 方法（它是 List 接口的一部分）相同。 请注意，add 方法颠倒了参数的顺序，以更紧密地匹配数组的使用。

参数：

Throws:

addElement

public void addElement(E obj)

将指定的组件添加到此向量的末尾，将其大小增加一。 如果该向量的大小变得大于其容量，则该向量的容量会增加。

此方法在功能上与 add(E) 方法（它是 List 接口的一部分）相同。

参数：

removeElement

public boolean removeElement(Object obj)

从此向量中删除参数的第一个（最低索引）出现。 如果在该向量中找到对象，则向量中具有大于或等于对象索引的索引的每个分量将向下移动以具有比其先前具有的值小一的索引。

此方法在功能上与 remove(java.lang.Object) 方法（它是 List 接口的一部分）相同。

参数：

返回:

如果参数是这个向量的一个组成部分，则为 true； 否则为 false。

removeAllElements

public void removeAllElements()

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

此方法在功能上与 clear() 方法（它是 List 接口的一部分）相同。

clone

public Object clone()

返回此向量的克隆。 该副本将包含对内部数据数组的克隆的引用，而不是对该 Vector 对象的原始内部数据数组的引用。

覆盖：

在类 Object 中克隆

返回:

该载体的克隆

toArray

public Object[] toArray()

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

指定者：

接口 CollectionE 中的 toArray

指定者：

接口 ListE 中的 toArray

覆盖：

AbstractCollectionE 类中的 toArray

返回:

包含此集合中所有元素的数组

toArray

public <T> T[] toArray(T[] a)

以正确的顺序返回包含此 Vector 中所有元素的数组； 返回数组的运行时类型是指定数组的运行时类型。 如果 Vector 适合指定的数组，则在其中返回。 否则，将使用指定数组的运行时类型和此 Vector 的大小分配一个新数组。

如果向量适合指定的数组并有剩余空间（即，数组的元素多于向量），则数组中紧跟向量末尾的元素设置为空。 （仅当调用者知道 Vector 不包含任何 null 元素时，这在确定 Vector 的长度时才有用。）

指定者：

接口 CollectionE 中的 toArray

指定者：

接口 ListE 中的 toArray

覆盖：

AbstractCollectionE 类中的 toArray

类型参数：

参数:

返回:

包含 Vector 元素的数组

Throws:

get

public E get(int index)

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

指定者：

进入接口 ListE

指定者：

进入类 AbstractListE

参数：

返回:

指定索引处的对象

Throws:

set

public E set(int index, E element)

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

指定者：

在接口 ListE 中设置

覆盖：

在类 AbstractListE 中设置

参数：

返回:

先前在指定位置的元素

Throws:

add

public boolean add(E e)

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

指定者：

添加接口CollectionE

指定者：

添加接口ListE

覆盖：

添加类 AbstractListE

参数：

返回:

true（由 Collection#add 指定）

remove

public boolean remove(Object o)

删除此 Vector 中指定元素的第一个匹配项 如果 Vector 不包含该元素，则它不变。 更正式地说，删除具有最低索引 i 的元素，使得 (o==null ? get(i)==null : o.equals(get(i))) （如果存在这样的元素）。

指定者：

在接口 CollectionE 中删除

指定者：

在接口 ListE 中删除

覆盖：

在类 AbstractCollectionE 中删除

参数：

返回:

如果 Vector 包含指定元素，则为 true

add

public void add(int index, E element)

在此 Vector 中的指定位置插入指定元素。 将当前位于该位置的元素（如果有）和任何后续元素向右移动（将其索引加一）。

指定者：

添加接口ListE

覆盖：

添加类 AbstractListE

参数：

Throws:

remove

public E remove(int index)

移除此 Vector 中指定位置的元素。 将任何后续元素向左移动（从它们的索引中减去 1）。 返回从 Vector 中删除的元素。

指定者：

在接口 ListE 中删除

覆盖：

在类 AbstractListE 中删除

参数：

返回:

被移除的元素

Throws:

clear

public void clear()

从此 Vector 中删除所有元素。 此调用返回后 Vector 将为空（除非它引发异常）。

指定者：

在接口 CollectionE 中清除

指定者：

在接口 ListE 中清除

覆盖：

在类 AbstractListE 中清除

containsAll

public boolean containsAll(Collection<?> c)

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

指定者：

接口 CollectionE 中的 containsAll

指定者：

接口 ListE 中的 containsAll

覆盖：

类 AbstractCollectionE 中的 containsAll

参数：

返回:

如果此 Vector 包含指定集合中的所有元素，则为 true

Throws:

addAll

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

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

指定者：

接口 CollectionE 中的 addAll

指定者：

接口 ListE 中的 addAll

覆盖：

类 AbstractCollectionE 中的 addAll

参数：

返回:

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

Throws:

removeAll

public boolean removeAll(Collection<?> c)

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

指定者：

接口 CollectionE 中的 removeAll

指定者：

接口 ListE 中的 removeAll

覆盖：

类 AbstractCollectionE 中的 removeAll

参数：

返回:

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

Throws:

retainAll

public boolean retainAll(Collection<?> c)

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

指定者：

接口CollectionE中的retainAll

指定者：

接口 ListE 中的 retainAll

覆盖：

类 AbstractCollectionE 中的 retainAll

参数：

返回:

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

Throws:

addAll

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

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

指定者：

接口 ListE 中的 addAll

覆盖：

类 AbstractListE 中的 addAll

参数：

返回:

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

Throws:

equals

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 中的等于

参数：

返回:

如果指定的 Object 等于此 Vector，则为 true

hashCode

public int hashCode()

返回此 Vector 的哈希码值。

指定者：

接口 CollectionE 中的 hashCode

指定者：

接口 ListE 中的 hashCode

覆盖：

AbstractListE 类中的 hashCode

返回:

此列表的哈希码值

toString

public String toString()

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

覆盖：

类 AbstractCollectionE 中的 toString

返回:

此集合的字符串表示形式

subList

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 类中的子列表

参数：

返回:

此列表中指定范围的视图

Throws:

removeRange

protected void removeRange(int fromIndex, int toIndex)

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

覆盖：

AbstractListE 类中的 removeRange

参数：

listIterator

public ListIteratorE listIterator(int index)

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

返回的列表迭代器是快速失败的。

指定者：

接口 ListE 中的 listIterator

覆盖：

AbstractListE 类中的 listIterator

参数：

返回:

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

Throws:

listIterator

public ListIteratorE listIterator()

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

返回的列表迭代器是快速失败的。

指定者：

接口 ListE 中的 listIterator

覆盖：

AbstractListE 类中的 listIterator

返回:

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

iterator

public IteratorE iterator()

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

返回的迭代器是快速失败的。

指定者：

接口 CollectionE 中的迭代器

指定者：

接口 IterableE 中的迭代器

指定者：

接口 ListE 中的迭代器

覆盖：

AbstractListE 类中的迭代器

返回:

以正确顺序遍历此列表中的元素的迭代器

forEach

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

从接口复制的描述：Iterable

对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。 除非实现类另有规定，否则按迭代顺序执行操作（如果指定了迭代顺序）。 操作引发的异常将转发给调用者。

指定者：

接口 IterableE 中的 forEach

参数：

removeIf

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

从接口复制的描述：集合

删除此集合中满足给定谓词的所有元素。 在迭代期间或由谓词引发的错误或运行时异常将转发给调用者。

指定者：

接口 CollectionE 中的 removeIf

参数：

返回:

如果删除了任何元素，则为 true

replaceAll

public void replaceAll(UnaryOperatorE operator)

从接口复制的描述：列表

将此列表的每个元素替换为将运算符应用于该元素的结果。 操作员抛出的错误或运行时异常被转发给调用者。

指定者：

接口 ListE 中的 replaceAll

参数：

sort

public void sort(Comparator<? super E> c)

从接口复制的描述：列表

根据指定 Comparator 产生的顺序对该列表进行排序。

此列表中的所有元素必须使用指定的比较器进行相互比较（即 c.compare(e1, e2) 不得为列表中的任何元素 e1 和 e2 抛出 ClassCastException）。

如果指定的比较器为空，则此列表中的所有元素都必须实现 Comparable 接口，并且应使用元素的 Comparable。

此列表必须是可修改的，但不需要调整大小。

指定者：

在接口 ListE 中排序

参数：

spliterator

public SpliteratorE spliterator()

在此列表中的元素上创建一个后期绑定和快速失败的拆分器。

Spliterator 报告 Spliterator#SIZED、Spliterator#SUBSIZED 和 Spliterator#ORDERED。 覆盖实现应记录附加特征值的报告。

指定者：

接口 CollectionE 中的分离器

指定者：

接口 IterableE 中的分离器

指定者：

接口 ListE 中的分离器

返回:

此列表中元素的拆分器