當前位置: 首頁>>代碼示例 >>用法及示例精選 >>正文


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。非經特殊聲明,原始代碼版權歸原作者所有,本譯文未經允許或授權,請勿轉載或複製。