Java 中 Vector 和 Array 的区别

2024年9月10日 | 阅读 9 分钟

在 Java 编程的世界里，数据结构在高效存储和操作数据方面起着至关重要的作用。为此，两种常用的数据结构是 Vector 和 Array。虽然两者都用于存储元素的集合，但它们之间存在明显的区别，使其适用于不同的场景。在本节中，我们将探讨 Java 中 Vector 和 Array 之间的差异。

Java 数组

Java 中的数组是一种固定大小、同质数据结构，用于存储相同类型元素的集合。数组具有静态长度，这意味着大小在声明时确定，并且在运行时无法更改。

它们通过索引提供对元素的直接访问，这使得数组操作快速高效。

文件名：ArrayExample.java

public class ArrayExample {
    public static void main(String[] args) {
        // Declaration and initialization of an array
        int[] intArray = new int[3];
        // Assigning values to array elements
        intArray[0] = 1;
        intArray[1] = 2;
        intArray[2] = 3;
        // Accessing array elements
        for (int i = 0; i < intArray.length; i++) {
            System.out.println("Element at index " + i + ": " + intArray[i]);
        }
    }
}

输出

Element at index 0: 1
Element at index 1: 2
Element at index 2: 3

Java Vector

Vector 是 Java 集合框架中一种动态可调整大小的类似数组的数据结构。Vector 可以动态地增长或缩小，从而灵活地管理其包含的元素数量。

Vector 属于 java.util 包，并实现 List 接口，提供了各种操作方法。让我们通过一些 Java 中数组和 Vector 的简单示例来阐述它们的区别。

文件名：VectorExample.java

import java.util.Vector;
public class VectorExample {
    public static void main(String[] args) {
        // Declaration and initialization of a Vector
        Vector<Integer> integerVector = new Vector<>();
        // Adding elements to the Vector
        integerVector.add(1);
        integerVector.add(2);
        integerVector.add(3);
        // Accessing vector elements
        for (int i = 0; i < integerVector.size(); i++) {
            System.out.println("Element at index " + i + ": " + integerVector.get(i));
        }
    }
}

输出

Element at index 0: 1
Element at index 1: 2
Element at index 2: 3

程序比较

在数组示例中，我们声明并初始化了一个具有固定大小的数组。然后，我们使用索引为其元素赋值并访问它们。

在 Vector 示例中，我们使用了 java.util 包中的 Vector 类。Vector 是动态的，可以根据需要增长或缩小。我们使用 add() 方法添加元素，并使用 get() 方法访问它们。

两个示例都输出了数组或 Vector 中存在的元素，演示了每种数据结构的基本操作。

大小灵活性

Array

一旦创建了数组，其大小将保持不变，我们无法动态更改它。要调整数组大小，我们需要创建一个新数组并将元素从旧数组复制到新数组。

Java 数组（固定大小）

文件名：ArrayExample.java

public class ArrayExample {
    public static void main(String[] args) {
        // Declaration and initialization of an array with a fixed size
        int[] intArray = new int[3];
        // Assigning values to array elements
        intArray[0] = 1;
        intArray[1] = 2;
        intArray[2] = 3;
        // Attempting to resize the array (not possible)
        // This will result in compilation error
         intArray[3] = 4;// commenting this line will not result in an error
        // Accessing array elements
        for (int i = 0; i < intArray.length; i++) {
            System.out.println("Element at index " + i + ": " + intArray[i]);
        }
    }
}

输出

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
at ArrayResizeErrorExample.main(ArrayResizeErrorExample.java:12)

在上面的示例中，尝试通过创建具有不同大小的新数组来调整数组大小将导致编译错误。

以下程序克服了编译错误。

文件名：ArrayExample.java

public class ArrayExample {
    public static void main(String[] args) {
        // Declaration and initialization of an array with a fixed size
        int[] intArray = new int[3];
        // Assigning values to array elements
        intArray[0] = 1;
        intArray[1] = 2;
        intArray[2] = 3;
        // Attempting to resize the array (not possible)
        // This will result in creating a new array and copying elements
        int[] newArray = new int[5];
        System.arraycopy(intArray, 0, newArray, 0, intArray.length);
        intArray = newArray;
        // Assigning new values to additional elements
        intArray[3] = 4;
        intArray[4] = 5;
        // Accessing array elements
        for (int i = 0; i < intArray.length; i++) {
            System.out.println("Element at index " + i + ": " + intArray[i]);
        }
    }
}

输出

Element at index 0: 1
Element at index 1: 2
Element at index 2: 3
Element at index 3: 4
Element at index 4: 5

Vector

Vector 是动态的，可以使用 add() 和 remove() 等方法在运行时调整其大小。Vector 类会自动处理底层数组的大小调整，从而提供一种方便的方法来管理集合的大小。

让我们创建示例来演示 Java 中数组和 Vector 的大小灵活性。

Java Vector（可调整大小）

文件名：VectorExample.java

import java.util.Vector;
public class VectorExample {
    public static void main(String[] args) {
        // Declaration and initialization of a Vector
        Vector<Integer> integerVector = new Vector<>();
        // Adding elements to the Vector
        integerVector.add(1);
        integerVector.add(2);
        integerVector.add(3);
        // Resizing the Vector dynamically
        integerVector.add(4);
        integerVector.add(5);
        // Accessing vector elements
        for (int i = 0; i < integerVector.size(); i++) {
            System.out.println("Element at index " + i + ": " + integerVector.get(i));
        }
    }
}

输出

Element at index 0: 1
Element at index 1: 2
Element at index 2: 3
Element at index 3: 4
Element at index 4: 5

在此示例中，在添加初始元素后，通过添加另外两个元素来动态调整 Vector 的大小。Vector 在运行时可以增长或缩小，从而灵活地管理其包含的元素数量。

同步

Array

Java 数组不是同步的，这意味着它们不是线程安全的。如果多个线程同时访问或修改数组，我们可能会遇到数据不一致的问题。

Java 数组（不同步）

文件名：ArrayThreadExample.java

public class ArrayThreadExample {
    public static void main(String[] args) {
        // Declaration and initialization of an array
        int[] intArray = new int[3];
        // Creating two threads that modify the array concurrently
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < intArray.length; i++) {
                intArray[i]++;
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < intArray.length; i++) {
                intArray[i]--;
            }
        });
        // Start the threads
        thread1.start();
        thread2.start();
        try {
            // Wait for threads to complete
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Accessing array elements after concurrent modification
        for (int i = 0; i < intArray.length; i++) {
            System.out.println("Element at index " + i + ": " + intArray[i]);
        }
    }
}

输出

Element at index 0: 0
Element at index 1: 0
Element at index 2: 0

在此示例中，两个线程在没有任何同步的情况下同时修改数组。因此，可能会发生数据不一致，并且数组元素的最终值可能有所不同。

Vector

Vector 默认是同步的，确保多个线程可以安全地访问和修改它们。虽然同步会带来开销，但在线程安全是一个问题的场景中有益。

让我们创建示例来演示在多线程场景中数组和 Vector 之间的同步差异。

Java Vector（同步）

文件名：VectorThreadExample.java

import java.util.Vector;
public class VectorThreadExample {
    public static void main(String[] args) {
        // Declaration and initialization of a Vector
        Vector<Integer> integerVector = new Vector<>();
        // Creating two threads that modify the vector concurrently
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                integerVector.add(i);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                integerVector.remove(0);
            }
        });
        // Start the threads
        thread1.start();
        thread2.start();
        try {
            // Wait for threads to complete
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Accessing vector elements after concurrent modification
        for (int i = 0; i < integerVector.size(); i++) {
            System.out.println("Element at index " + i + ": " + integerVector.get(i));
        }
    }
}

输出

Element at index 0: 2
Element at index 1: 1

在此示例中，Vector 类会自动处理同步。因此，即使多个线程同时修改 Vector，数据也能保持一致，确保线程安全。

性能

Array

由于其固定大小和直接的元素访问，数组通常为简单操作提供更好的性能。对于大小已知且保持不变的场景，数组是更高效的选择。

Java 数组（性能更好）

文件名：ArrayPerformanceExample.java

public class ArrayPerformanceExample {
    public static void main(String[] args) {
        // Declaration and initialization of an array
        int[] intArray = new int[1000000];
        // Timing the array element assignment operation
        long startTime = System.nanoTime();
        for (int i = 0; i < intArray.length; i++) {
            intArray[i] = i;
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        // Accessing array elements after assignment
        for (int i = 0; i < 10; i++) {
            System.out.println("Element at index " + i + ": " + intArray[i]);
        }
        System.out.println("Time taken for array assignment: " + duration + " nanoseconds");
    }
}

输出

Element at index 0: 0
Element at index 1: 1
Element at index 2: 2
Element at index 3: 3
Element at index 4: 4
Element at index 5: 5
Element at index 6: 6
Element at index 7: 7
Element at index 8: 8
Element at index 9: 9
Time taken for array assignment: 70000 nanoseconds

在此示例中，我们对数组元素赋值操作进行计时，由于直接的元素访问和数组的固定大小，该操作相对较快。

Vector

Vector 由于其动态性和同步性，可能会产生额外的开销，导致在某些操作中比数组稍慢。然而，在特定用例中，动态调整大小和线程安全的便利性可能会弥补性能上的权衡。

让我们创建示例来演示在简单操作方面数组和 Vector 之间的性能差异。

Java Vector（潜在开销）

文件名：VectorPerformanceExample.java

import java.util.Vector;
public class VectorPerformanceExample {
    public static void main(String[] args) {
        // Declaration and initialization of a Vector
        Vector<Integer> integerVector = new Vector<>();
        // Timing the vector element add operation
        long startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            integerVector.add(i);
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        // Accessing vector elements after addition
        for (int i = 0; i < 10; i++) {
            System.out.println("Element at index " + i + ": " + integerVector.get(i));
        }
        System.out.println("Time taken for vector addition: " + duration + " nanoseconds");
    }
}

输出

Element at index 0: 0
Element at index 1: 1
Element at index 2: 2
Element at index 3: 3
Element at index 4: 4
Element at index 5: 5
Element at index 6: 6
Element at index 7: 7
Element at index 8: 8
Element at index 9: 9
Time taken for vector addition: 1600000 nanoseconds

在此示例中，我们对 Vector 元素添加操作进行计时。由于 Vector 类中潜在的动态调整大小和同步开销，这通常需要更多时间。具体的性能特征可能因用例和环境而异。

Java Vector 与 Array

以下是 Java 中 Vector 和 Array 之间差异的表格表示

特性	Array	Vector
定义	它是一种固定大小、同质数据结构。	它是一种动态、可调整大小的类似数组的数据结构。
大小	其大小是静态的（在声明时确定）。	它是动态大小的（可以在运行时调整大小）。
调整大小操作	它需要创建一个新数组并复制元素。	它可以使用 add() 和 remove() 等方法进行调整大小。
Interface	它不是 Java 集合框架的一部分。	它是 Java 集合框架的一部分（实现了 List 接口）。
同步	不同步（不是线程安全的）。	默认同步（线程安全的）。
性能	由于其固定大小和直接访问，通常更快。	由于动态调整大小和同步，可能会有稍多的开销。
包	没有特定包（属于核心语言）。	java.util 包（属于 Java 集合框架）。
用法建议	它适用于大小固定且已知的情况。	当需要动态调整大小和线程安全时，它很合适。

理解这些区别可以帮助开发人员根据其 Java 应用程序的特定需求选择合适的数据结构。

结论

总之，Vector 和 Array 各有优缺点，两者之间的选择取决于手头任务的具体需求。数组适用于需要固定大小、快速访问集合的场景，而 Vector 则以牺牲一些性能开销为代价提供了灵活性和线程安全。理解这些差异对于在设计和实现 Java 应用程序时做出明智的决定至关重要。

下一话题Java 中的重复类错误

Java 中 Vector 和 Array 的区别

Java 数组

Java Vector

程序比较

大小灵活性

Array

Vector

同步

Array

Vector

性能

Array

Vector

Java Vector 与 Array

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中 Vector 和 Array 的区别

Java 数组

Java Vector

程序比较

大小灵活性

Array

Vector

同步

Array

Vector

性能

Array

Vector

Java Vector 与 Array

结论

相关帖子

Java 中是否可以继承 final 方法

Best Practices to Handle Exceptions in Java

Java 中的 Jacobsthal 数

Java 中计算创建的类对象数量

Java 8 中的 Future

Set vs Map in Java

Playfair Cipher Program in Java

Java 中的逆层序遍历

Java 中组件和容器的区别

Minimum Insertions to Make a Co-prime Array in Java

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器