当前位置: 首页>>代码示例 >>用法及示例精选 >>正文


Java Vector用法及代码示例


Vector 类实现了可增长的对象数组。向量属于遗留类,但现在它与集合完全兼容。它被发现于java.util包并实施List Interface接口,因此我们可以使用List接口的所有方法,如下所示:

Vector Class in Java

  • Vector 实现了动态数组,这意味着它可以根据需要增长或缩小。与数组一样,它包含可以使用整数索引访问的组件。
  • 它们非常相似ArrayList,但是 Vector 是同步的,并且有一些集合框架不包含的遗留方法。
  • 它还像 ArrayList 一样维护插入顺序。尽管如此,它还是很少在非线程环境中使用,因为它是同步的,因此,它在添加、搜索、删除和更新元素层面的性能很差。
  • Vector 类返回的迭代器是fail-fast。在并发修改的情况下,它会失败并抛出并发修改异常。

用法:

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

这里, E是元素的类型。

  • 它延伸AbstractList并实施List Interface接口。
  • 它实现了 Serialized、Cloneable、Iterable<E>、Collection<E>、List<E>、RandomAccess 接口。
  • 直接已知的子类是Stack.

关于向量容量增量的要点如下:

如果指定了增量,Vector将在每个分配周期中根据它进行扩展。不过,如果未指定增量,则向量的容量在每个分配周期中都会加倍。 Vector定义了三个受保护的数据成员:

  • int容量增量:包含增量值。
  • int元素计数:当前存储在向量中的元素数量。
  • 对象元素数据[]:保存向量的数组存储在其中。

向量声明中的常见错误如下 如下

  • 向量抛出一个IllegalArgumentException如果定义的向量的InitialSize为负。
  • 如果指定的集合为 null,则抛出NullPointerException.

构造函数

1.Vector():创建一个默认向量,初始容量为10。

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

2.向量(int大小):创建一个向量,其初始容量由大小指定。

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

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

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

4.矢量(集合c):创建一个包含集合 c 的元素的向量。

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

Vector 类中的方法

METHOD

DESCRIPTION

Vector add()将指定元素追加到此 Vector 的末尾。
Vector add()在此 Vector 中的指定位置插入指定元素。

Vector addAll()

Vector addAll()

将指定 Collection 中的所有元素按照指定 Collection 的迭代器返回的顺序追加到此 Vector 的末尾。

Vector addAll()

Vector addAll()

将指定 Collection 中的所有元素插入此 Vector 的指定位置。
Vector addElement()将指定的组件添加到此向量的末尾,将其大小增加一。
Vector capacity()返回该向量的当前容量。
Vector clear()从此向量中删除所有元素。
Vector clone()返回此向量的克隆。
Vector contains()如果此向量包含指定元素,则返回 true。
Vector containsAll()如果此 Vector 包含指定 Collection 中的所有元素,则返回 true。
Vector copyInto()将此向量的分量复制到指定的数组中。
Vector elementAt()返回指定索引处的组件。
Vector elements()返回此向量的分量的枚举。
ArrayList.ensureCapacity()如有必要,增加此向量的容量,以确保它至少可以容纳最小容量参数指定的组件数量。
Vector equals()比较指定的 Object 与此 Vector 是否相等。
Vector firstElement()返回该向量的第一个分量(索引 0 处的项)。

Vector forEach()

Vector forEach()

对 Iterable 的每个元素执行给定的操作,直到处理完所有元素或该操作引发异常。
Vector get()返回此 Vector 中指定位置的元素。
Vector hashCode()返回此 Vector 的哈希码值。
Vector indexOf()

返回指定元素在此向量中第一次出现的索引,

如果该向量不包含该元素,则为 -1。

Vector indexOf()返回指定元素在此向量中第一次出现的索引,从该索引向前搜索,如果未找到该元素,则返回 -1。
Vector insertElementAt()将指定对象作为组件插入此向量中的指定索引处。
Vector isEmpty()测试该向量是否没有分量。
Vector iterator()以正确的顺序返回此列表中元素的迭代器。
Vector lastElement()返回向量的最后一个分量。
Vector lastIndexOf()

返回此向量中最后一次出现的指定元素的索引,

如果该向量不包含该元素,则为 -1。

Vector lastIndexOf()返回此向量中最后一次出现的指定元素的索引,从该索引向后搜索,如果未找到该元素,则返回 -1。
Vector listIterator()返回此列表中元素的列表迭代器(按正确的顺序)。
Vector listIterator()

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

从列表中的指定位置开始。

Vector remove()删除此 Vector 中指定位置的元素。
Vector remove()删除此 Vector 中第一次出现的指定元素。如果 Vector 不包含该元素,则它不会改变。
Vector removeAll()从此 Vector 中删除指定 Collection 中包含的所有元素。
Vector removeAllElements()从此向量中删除所有组件并将其大小设置为零。
Vector removeElement()从此向量中删除第一个 (lowest-indexed) 出现的参数。
Vector removeElementAt()删除指定索引处的组件。
Vector removeIf()删除此集合中满足给定谓词的所有元素。

Vector removeRange()

Vector removeRange()

从此列表中删除索引介于 fromIndex(包含)和 toIndex(不包含)之间的所有元素。
ReplaceAll(UnaryOperator<E> 运算符)将此列表中的每个元素替换为将运算符应用于该元素的结果。
Vector retainAll()仅保留指定 Collection 中包含的此 Vector 中的元素。
Vector set()将此 Vector 中指定位置的元素替换为指定元素。
Vector setElementAt()将此向量的指定索引处的组件设置为指定对象。
Vector setSize()设置该向量的大小。
Vector size()返回此向量中的分量数。
Collections.sort()根据指定比较器产生的顺序对此列表进行排序。
ArrayList spliterator()在此列表中的元素上创建后期绑定和fail-fast Spliterator。
Vector subList()返回此列表中介于 fromIndex(包含)和 toIndex(不包含)之间的部分的视图。
Vector toArray()返回一个数组,其中按正确顺序包含此 Vector 中的所有元素。
Vector toArray()返回一个数组,其中按正确顺序包含此 Vector 中的所有元素;返回数组的运行时类型是指定数组的运行时类型。
Vector toString()返回此 Vector 的字符串表示形式,其中包含每个元素的字符串表示形式。
Vector trimToSize()将此向量的容量修剪为向量的当前大小。

在讨论此类的方法之前,让我们首先讨论并实现如何创建和使用 Vector。

例子:

// Java Program to Demonstrate Working of Vector
// Via Creating and Using It

// Importing required classes
import java.io.*;
import java.util.*;

// Main class
class GFG {

    // Main driver method
    public static void main(String[] args)
    {
        // Size of the Vector
        int n = 5;

        // Declaring the Vector with
        // initial size n
        Vector<Integer> v = new Vector<Integer>(n);

        // Appending new elements at
        // the end of the vector
        for (int i = 1; i <= n; i++)
            v.add(i);

        // Printing elements
        System.out.println(v);

        // Remove element at index 3
        v.remove(3);

        // Displaying the vector
        // after deletion
        System.out.println(v);

        // iterating over vector elements
        // using for loop
        for (int i = 0; i < v.size(); i++)

            // Printing elements one by one
            System.out.print(v.get(i) + " ");
    }
}

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

Note:

  • If the vector increment is not specified then it’s capacity will be doubled in every increment cycle.
  • The capacity of a vector cannot be below the size, it may equal to it.

Java中Vector类的各种操作

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

  1. 添加元素
  2. 更新元素
  3. 删除元素
  4. 迭代元素

操作1: 添加元素

为了将元素添加到 Vector,我们使用Vector add()方法。该方法被重载以根据不同的参数执行多个操作。下面列出了它们:

  • 添加(对象):该方法用于在 Vector 的末尾添加一个元素。
  • 添加(int索引,对象):此方法用于在 Vector 中的特定索引处添加元素。

例子:

// Java Program to Add Elements in Vector Class

// Importing required classes
import java.io.*;
import java.util.*;

// Main class
// AddElementsToVector
class GFG {

    // Main driver method
    public static void main(String[] arg)
    {

        // Case 1
        // Creating a default vector
        Vector v1 = new Vector();

        // Adding custom elements
        // using add() method
        v1.add(1);
        v1.add(2);
        v1.add("geeks");
        v1.add("forGeeks");
        v1.add(3);

        // Printing the vector elements to the console
        System.out.println("Vector v1 is " + v1);

        // Case 2
        // Creating generic vector
        Vector<Integer> v2 = new Vector<Integer>();

        // Adding custom elements
        // using add() method
        v2.add(1);
        v2.add(2);
        v2.add(3);

        // Printing the vector elements to the console
        System.out.println("Vector v2 is " + v2);
    }
}

输出:


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

操作2: 更新元素

添加元素后,如果我们想更改元素,可以使用Vector set()方法。由于 Vector 是有索引的,因此我们希望更改的元素是通过元素的索引来引用的。因此,此方法采用索引和要在该索引处插入的更新元素。

示例

// Java code to change the
// elements in vector class
import java.util.*; 

// Driver Class
public class UpdatingVector { 
      // Main Function
    public static void main(String args[]) 
    { 
        // Creating an empty Vector 
        Vector<Integer> vec_tor = new Vector<Integer>(); 

        // Use add() method to add elements in the vector 
        vec_tor.add(12); 
        vec_tor.add(23); 
        vec_tor.add(22); 
        vec_tor.add(10); 
        vec_tor.add(20); 

        // Displaying the Vector 
        System.out.println("Vector: " + vec_tor); 

        // Using set() method to replace 12 with 21 
        System.out.println("The Object that is replaced is: "
                        + vec_tor.set(0, 21)); 

        // Using set() method to replace 20 with 50 
        System.out.println("The Object that is replaced is: "
                        + vec_tor.set(4, 50)); 

        // Displaying the modified vector 
        System.out.println("The new Vector is:" + vec_tor); 
    } 
}

输出
Vector: [12, 23, 22, 10, 20]
The Object that is replaced is: 12
The Object that is replaced is: 20
The new Vector is:[21, 23, 22, 10, 50]

操作3: 删除元素

为了从 Vector 中删除元素,我们可以使用Vector remove()方法。该方法被重载以根据不同的参数执行多个操作。他们是:

  • 删除(对象):该方法用于从 Vector 中删除对象。如果存在多个此类对象,则删除第一个出现的对象。
  • 删除(整数索引):由于 Vector 是有索引的,因此该方法采用一个整数值,该整数值只是删除 Vector 中该特定索引处存在的元素。删除元素后,所有元素都会向左移动以填充空间,并更新对象的索引。

示例

// Java code illustrating the removal
// of elements from vector

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

class RemovingElementsFromVector {
  
    public static void main(String[] arg)
    {
        // Create default vector of capacity 10
        Vector v = new Vector();

        // Add elements using add() method
        v.add(1);
        v.add(2);
        v.add("Geeks");
        v.add("forGeeks");
        v.add(4);

        // Removing first occurrence element at 1
        v.remove(1);

        // Checking vector
        System.out.println("after removal: " + v);
    }
}

输出:

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

操作4:迭代向量

有多种方法可以迭代 Vector。最著名的方法是将基本的 for 循环与Vector get()获取特定索引处的元素的方法循环高级.

示例

// Java program to iterate the elements
// in a Vector

import java.util.*;

public class IteratingVector {

    public static void main(String args[])
    {
          // create an instance of vector
        Vector<String> v = new Vector<>();

          // Add elements using add() method
        v.add("Geeks");
        v.add("Geeks");
        v.add(1, "For");

        // Using the Get method and the
        // for loop
        for (int i = 0; i < v.size(); i++) {

            System.out.print(v.get(i) + " ");
        }

        System.out.println();

        // Using the for each loop
        for (String str : v)
            System.out.print(str + " ");
    }
}

输出
Geeks For Geeks 
Geeks For Geeks

Note: Do give a read to the ArrayList vs Vector class in Java to grasp it better.

在 Java 中,Vector 类是 Java Collections Framework 的一部分,提供 List 接口的动态数组实现。它是在 Java 的原始版本 (Java 1.0) 中添加的,并提供了许多操作向量元素的方法,包括添加、插入和删除元素。

下面是一个简单的示例,演示了如何在 Java 中使用 Vector:

import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        // Create a new vector
        Vector<Integer> v = new Vector<>(3, 2);

        // Add elements to the vector
        v.addElement(1);
        v.addElement(2);
        v.addElement(3);

        // Insert an element at index 1
        v.insertElementAt(0, 1);

        // Remove the element at index 2
        v.removeElementAt(2);

        // Print the elements of the vector
        for (int i : v) {
            System.out.println(i);
        }
    }
}

输出
1
0
3

请注意,Vector 类是同步的,这意味着多个线程可以访问同一向量而不会引起问题。但是,这种同步是以性能为代价的,因此如果您不需要在多个线程之间共享向量,通常最好使用不同步的替代类,例如 ArrayList。

在Java中使用Vector的优点:

  1. 同步:如前所述,Vector 是同步的,因此可以安全地在多线程环境中使用。
  2. 动态大小:Vector 的大小可以随着元素的添加或删除而动态增大或缩小,因此您不必担心设置可容纳所有元素的初始大小。
  3. 旧版支持:Vector 自诞生以来一直是 Java 的一部分,并且仍然受到支持,因此如果您需要使用使用 Vector 的旧版 Java 代码,那么它是一个不错的选择。

在Java中使用Vector的缺点:

  1. 性能:与其他集合类(例如 ArrayList)相比,Vector 中的同步可能会导致性能降低。
  2. 遗留代码:虽然 Vector 仍然受支持,但较新的 Java 代码通常是使用更现代的集合类编写的,因此可能更难找到 Vector 的示例和支持。
  3. 不必要的开销:如果你不需要Vector的同步函数,使用它会给你的代码增加不必要的开销。

参考书

Naftalin 和 Wadler 编写的 “Java Collections” 是一本很好的学习 Java 集合框架和 Vector 的参考书。本书全面介绍了 Java 集合框架(包括 Vector),并包含许多示例和练习,以帮助您了解如何有效地使用这些类。



相关用法


注:本文由纯净天空筛选整理自佚名大神的英文原创作品 Vector Class in Java。非经特殊声明,原始代码版权归原作者所有,本译文未经允许或授权,请勿转载或复制。