Java 中的 Vector 类

Vector 类实现了一个可增长的对象数组。Vector 类属于传统类，但现在与集合完全兼容。它被发现在 java.util 包中，并实现了 List 接口，因此我们可以使用所有 List 接口的方法，如下所示：

Java 中的 Vector 类

Vector 实现了一个动态数组，这意味着它可以根据需要增长或缩小。和数组一样，它包含可以使用整数索引访问的组件。
它们非常类似于 ArrayList ，但 Vector 是同步的，并且具有一些集合框架中不存在的传统方法。
它还保持了插入顺序，就像 ArrayList 一样。但是，在非线程环境下很少使用它，因为它是同步的，因此在添加、搜索、删除和更新其元素时性能较差。
Vector 类返回的迭代器是故障快速的。在并发修改的情况下，它会失败并抛出 ConcurrentModificationException 。

语法:

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

这里， E 是元素的类型。

它扩展了 AbstractList ，并实现了 List 接口。
它实现了 Serializable、Cloneable、Iterable、Collection、List、RandomAccess 接口。
直接已知的子类是 Stack 。

关于 vector 容量的增量的重要点如下:

如果指定了增量，Vector 将按照它在每个分配周期中进行扩展。但如果未指定增量，则在每个分配周期中将 vector 容量加倍。Vector 定义了三个受保护的数据成员:

int capacityIncreament: 包含增量值。
int elementCount: 存储在其中的 vector 中当前的元素数量。
Object elementData[]: 存储向量的数组。

Vector 声明中的常见错误如下:

如果定义的 vector 的初始大小为负，则 Vector 抛出 IllegalArgumentException 。
如果指定的集合为 null，则抛出 NullPointerException 。

构造函数

1. Vector(): 创建一个默认的 vector，其初始容量为 10。

Vector<E> v = new Vector<E>();

2. Vector(int size): 创建一个其初始容量由 size 指定的向量。

Vector<E> v = new Vector<E>(int size);

3. Vector(int size, int incr): 创建一个其初始容量由 size 指定的向量，并且增量由 incr 指定。它指定每次向量被向上调整大小时要分配的元素数。

Vector<E> v = new Vector<E>(int size, int incr);

4. Vector(Collection c): 创建包含集合 c 的元素的向量。

Vector<E> v = new Vector<E>(Collection c);

Vector 类中的方法

方法	描述
add(E e)	将指定的元素添加到此Vector的末尾。
add(int index, E element)	在此Vector中指定位置插入指定的元素。
addAll(Collection c) \| 将指定Collection中的所有元素以它们被指定Collection的Iterator返回的顺序追加到此Vector的末尾。 addAll(int index, Collection c) \| 将指定Collection中的所有元素插入到此Vector中指定的位置。 addElement(E obj) \| 将指定的组件添加到此向量的末尾，其大小增加1。 capacity() \| 返回此向量的当前容量。 clear() \| 从此Vector中删除所有元素。 clone() \| 返回此vector的一个克隆。 contains(Object o) \| 如果此vector包含指定的元素，则返回true。 containsAll(Collection c)	如果此Vector包含指定Collection中的所有元素，则返回true。
copyInto(Object[] anArray)	将此Vector的组件复制到指定的数组中。
elementAt(int index)	返回指定索引处的元素。
elements()	返回此向量的组件的枚举。
ensureCapacity(int minCapacity)	如果需要，增加此Vector的容量，以确保它至少可以容纳由最小容量参数指定的组件数。
equals(Object o)	将指定的对象与此向量进行比较，以获得相等性。
firstElement()	返回此向量的第一个组件（索引为0的项）。
forEach(Consumer action) \| 对Iterable的每个元素执行给定的操作，直到所有元素都被处理完或操作抛出异常为止。 get(int index) \| 返回此Vector中指定位置的元素。 hashCode() \| 返回此Vector的哈希码值。 indexOf(Object o) \| 返回此vector中指定元素的第一次出现的索引，如果此vector不包含元素，则返回-1。 indexOf(Object o, int index) \| 返回在索引处向前搜索的指定元素在此vector中第一次出现的索引，如果未找到元素，则返回-1。 insertElementAt(E obj, int index) \| 在指定索引处将指定的对象作为此Vector的一个组件插入。 isEmpty() \| 测试此Vector是否没有组件。 iterator() \| 以正确顺序返回此列表中的元素的迭代器。 lastElement() \| 返回向量的最后一个组件。 lastIndexOf(Object o) \| 返回此vector中指定元素的最后一次出现的索引，如果未找到元素，则返回-1。 lastIndexOf(Object o, int index) \| 返回在从指定索引处向后搜索的元素的最后一次出现的索引，如果未找到元素，则返回-1。 remove(int index) \| 删除此Vector中指定位置处的元素。 remove(Object o) \| 删除此Vector中指定元素的第一个出现位置。 removeAll(Collection c)	删除此Vector中包含在指定Collection中的所有元素。
removeElement(Object obj)	从Vector中删除指定的组件。
removeElementAt(int index)	删除此Vector中指定位置处的组件。
removeIf(Predicate filter) \| 从此列表中删除满足给定谓词的所有元素。 retainAll(Collection c)	保留此Vector中仅包含在指定Collection中的元素。
set(int index, E element)	将此Vector中指定位置的元素设置为指定的元素。
setElementAt(E obj, int index)	将位于指定索引处的向量组件设置为指定的对象。
setSize(int newSize)	设置此Vector的大小。
size()	返回此向量中的组件数。
sort(Comparator c) \| 根据指定的Comparator对此列表进行排序。 spliterator() \| 创建一个元素分隔器，可以遍历列表中的元素。 subList(int fromIndex, int toIndex) \| 返回此列表中指定的fromIndex（含）和toIndex（不含）之间的部分视图。 toArray() \| 将此Vector中的组件作为对象数组返回。 toArray(T[] a) \| 将此Vector中的组件复制到指定的数组中。 toString() \| 返回此Vector的字符串表示形式。 trimToSize() \| 对此Vector的容量进行截断，使其等于向量的当前大小。 lastIndexOf(Object o, int index) \| 返回此向量中指定元素最后一个出现的索引，从索引开始向后搜索，如果找不到元素，则返回-1。 listIterator() \| 返回按正确顺序遍历此列表中所有元素的列表迭代器。 listIterator(int index) \| 返回按正确顺序遍历此列表中所有元素的列表迭代器，从列表中指定的位置开始。 remove(int index) \| 在此向量中删除指定位置的元素。 remove(Object o) \| 从此向量中删除指定元素的第一个出现位置。如果向量不包含该元素，则不做更改。 removeAll(Collection c)	从此向量中删除包含在指定集合中的所有元素。
removeAllElements()	删除此向量中的所有元素，并将其大小设置为零。
removeElement(Object obj)	删除此向量中第一个（最低索引的）出现的参数。
removeElementAt(int index)	删除指定索引处的组件。
removeIf(Predicate filter) \| 删除满足给定谓词的此集合的所有元素。 removeRange(int fromIndex, int toIndex) \| 删除此列表中索引在fromIndex（包括）和toIndex（排除）之间的所有元素。 replaceAll(UnaryOperator operator) \| 将此列表中的每个元素替换为将运算符应用于该元素的结果。 retainAll(Collection c)	仅保留此向量中包含在指定集合中的元素。
set(int index, E element)	将此向量中指定位置的元素替换为指定的元素。
setElementAt(E obj, int index)	将此向量中指定索引的组件设置为指定的对象。
setSize(int newSize)	设置此向量的大小。
size()	返回此向量中的组件数。
sort(Comparator<? super E> c)	根据指定比较器引起的顺序对此列表进行排序。
spliterator()	创建一个后期绑定和快速失败的Spliterator，该Spliterator遍历此列表中的元素。
subList(int fromIndex, int toIndex)	返回此列表在fromIndex（包括）和toIndex（排除）之间的部分的视图。 \| toArray() \| 以正确顺序包含此向量中所有元素的数组返回。
toArray(T[] a)	以正确顺序包含此向量中所有元素的数组返回；返回数组的运行时类型是指定数组的类型。
toString()	返回此向量的字符串表示形式，包含每个元素的字符串表示形式。
trimToSize()	将此向量的容量调整为向量的当前大小。

首先让我们讨论和实现如何创建和使用一个 Vector，在探讨这个类的方法之前。

例子：

// Java 程序演示了 Vector 的工作方式
// 通过创建和使用它
 
// 导入所需类
import java.io.*;
import java.util.*;
 
// 主类
class GFG {
 
    // 主方法
    public static void main(String[] args)
    {
        // Vector 的大小
        int n = 5;
 
        // 用初始大小 n 声明 Vector
        Vector<Integer> v = new Vector<Integer>(n);
 
        // 在向量末尾添加新元素
        for (int i = 1; i <= n; i++)
            v.add(i);
 
        // 打印元素
        System.out.println(v);
 
        // 删除索引为 3 的元素
        v.remove(3);
 
        // 删除后显示向量
        System.out.println(v);
 
        // 使用 for 循环迭代向量元素
        for (int i = 0; i < v.size(); i++)
 
            // 逐个打印元素
            System.out.print(v.get(i) + " ");
    }
}

输出

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

注意:

如果未指定向量增量，则其容量将在每个增量周期中加倍。
向量的容量不能低于其大小，可以等于它。

在 Java 中执行 Vector 类的各种操作

让我们讨论 Vector 类的各种操作，如下所示：

添加元素
更新元素
删除元素
遍历元素

操作 1: 添加元素

为了在 Vector 中添加元素，我们使用 add() 方法。此方法针对不同参数基于多个重载进行多个操作。它们如下所示：

add(Object): 此方法用于在 Vector 的末尾添加元素。
add(int index, Object): 此方法用于在 Vector 中的特定索引处添加元素。

例子:

// Java 程序向 Vector 类中添加元素
 
// 导入所需类
import java.io.*;
import java.util.*;
 
// 主类
// AddElementsToVector
class GFG {
 
    // 主方法
    public static void main(String[] arg)
    {
 
        // Case 1
        // 创建默认向量
        Vector v1 = new Vector();
 
        // 使用 add() 方法添加自定义元素
        v1.add(1);
        v1.add(2);
        v1.add("geeks");
        v1.add("forGeeks");
        v1.add(3);
 
        // 将向量元素打印到控制台
        System.out.println("Vector v1 is " + v1);
 
        // Case 2
        // 创建泛型向量
        Vector<Integer> v2 = new Vector<Integer>();
 
        // 使用 add() 方法添加自定义元素
       v2.add(1);
        v2.add(2);
        v2.add(3);
 
        // 将向量元素打印到控制台
        System.out.println("Vector v2 is " + v2);
    }
}

输出:

Java 中的 Vector 类

Vector v1 is [1, 2, geeks, forGeeks, 3]
Vector v2 is [1, 2, 3]

操作 2: 更新元素

添加元素后，如果我们希望更改元素，可以使用set()方法来实现。由于向量是有索引的，所以我们想要更改的元素是以元素的索引为参考的。因此，这个方法接受一个索引和要插入到该索引的更新元素。

例子

// Java代码来更改向量类中的元素

import java.util.*;

public class UpdatingVector {

    public static void main(String args[])
    {
        // 创建一个空向量
        Vector vec_tor = new Vector();

        // 使用add()方法向向量中添加元素
        vec_tor.add(12);
        vec_tor.add(23);
        vec_tor.add(22);
        vec_tor.add(10);
        vec_tor.add(20);

        // 显示向量
        System.out.println("Vector: " + vec_tor);

        // 使用set()方法将12替换为21
        System.out.println("被替换的对象为: " + vec_tor.set(0, 21));

        // 使用set()方法将20替换为50
        System.out.println("被替换的对象为: " + vec_tor.set(4, 50));

        // 显示修改后的向量
        System.out.println("新的向量为: " + vec_tor);
    }
}

输出结果

Vector: [12, 23, 22, 10, 20]
被替换的对象为: 12
被替换的对象为: 20
新的向量为: [21, 23, 22, 10, 50]

操作3：删除元素

为了从向量中删除元素，我们可以使用remove()方法。根据不同的参数，此方法被重载以执行多个操作。它们是：

remove(Object) ：此方法用于从Vector中删除一个对象。如果存在多个这样的对象，则将删除第一个出现的对象。
remove(int index) ：由于向量是有索引的，这个方法接受一个整数值，仅删除向量中特定索引处存在的元素。在删除元素后，所有元素向左移动以填充空间，并更新对象的索引。

例子

// Java代码演示从向量中删除元素

import java.util.*;
import java.io.*;

class RemovingElementsFromVector {

    public static void main(String[] arg)
    {

        // 创建默认容量为10的向量
        Vector v = new Vector();

          // 使用add()方法添加元素
        v.add(1);
        v.add(2);
        v.add("Geeks");
        v.add("forGeeks");
        v.add(4);

        // 删除索引为1的元素的第一个出现
        v.remove(1);

        // 检查向量
        System.out.println("after removal: " + v);
    }
}

输出结果：

after removal: [1, Geeks, forGeeks, 4]

操作4: 迭代向量

有多种方法可以遍历向量。最著名的方法是使用基本的for循环结合get()方法获取特定索引处的元素和高级for循环

例子

// Java程序遍历Vector中的元素
 
import java.util.*;
 
public class IteratingVector {
 
    public static void main(String args[])
    {
          // 创建一个vector实例
        Vector<String> v = new Vector<>();
 
          // 使用add方法添加元素
        v.add("Geeks");
        v.add("Geeks");
        v.add(1, "For");
 
        // 使用get方法和for循环
        for (int i = 0; i < v.size(); i++) {
 
            System.out.print(v.get(i) + " ");
        }
 
        System.out.println();
 
        // 使用for each循环
        for (String str : v)
            System.out.print(str + " ");
    }
}

输出

Geeks For Geeks 
Geeks For Geeks

在Java中，Vector类是Java集合框架的一部分，它提供了List接口的动态数组实现。Vector在Java的最初版本中添加（Java 1.0），并提供一些用于操作向量元素的方法，包括添加、插入和删除元素。

下面是一个简单的示例，演示如何在Java中使用向量：

import java.util.Vector;
 
public class VectorExample {
    public static void main(String[] args) {
        //创建新向量
        Vector<Integer> v = new Vector<>(3, 2);
 
        // 添加元素到向量
        v.addElement(1);
        v.addElement(2);
        v.addElement(3);
 
        // 在第1个索引处插入一个元素
        v.insertElementAt(0, 1);
 
        // 删除索引为2的元素
        v.removeElementAt(2);
 
        // 打印向量的元素
        for (int i : v) {
            System.out.println(i);
        }
    }
}