Vector in Java

The Vector class in Java is a synchronized implementation of a dynamic array. It's similar to the more commonly used ArrayList class, but with a key difference: thread safety.

Key Characteristics of Java Vector

  1. Dynamic Array: Like ArrayList, Vector can grow or shrink its size at runtime to accommodate adding or removing elements.
  2. Thread-Safe: This is the main distinction from ArrayList. Each method in Vector is synchronized, meaning only one thread can access and modify the vector at a time. This prevents race conditions (conflicts) in multithreaded environments.
  3. List Interface: Vector implements the List interface, providing functionalities like adding, removing, accessing, and searching elements.

When to Use Vector

  1. Thread-Safety is Crucial: If your application involves multiple threads concurrently accessing and modifying the same vector, Vector is the preferred choice due to its synchronized methods.
  2. Legacy Code: In older Java codebases, Vector might be used more frequently. However, for new development, ArrayList is generally recommended.

Performance Considerations

Synchronization Overhead: The synchronization in Vector comes at a performance cost. Adding, removing, searching, and updating elements are slower compared to the non-synchronized ArrayList. If thread safety isn't a concern, ArrayList is a better choice for performance reasons.

Creating a Vector

You can create a Vector in Java using its constructors. There are several constructors available, but the most common ones are:

  1. Vector(): Creates an empty Vector with an initial capacity of 10.
  2. Vector(int initialCapacity): Creates an empty Vector with the specified initial capacity.
  3. Vector(int initialCapacity, int capacityIncrement): Creates an empty Vector with the specified initial capacity and capacity increment.
import java.util.Vector; Vector<Integer> vector = new Vector<>(); Vector<String> names = new Vector<>(20);

Adding Elements

You can add elements to a Vector using the add() method. If the Vector runs out of capacity, it automatically increases its size.

vector.add(10); vector.add(20); vector.add(30);

Accessing Elements

You can access elements in a Vector using their index. The get() method is used for this purpose.

int firstElement = vector.get(0); // Retrieves the first element (10)

Removing Elements

Elements can be removed from a Vector using the remove() method. You can remove elements by index or by object.

vector.remove(0); // Removes the element at index 0 vector.remove(Integer.valueOf(20)); // Removes the first occurrence of the specified element

Iterating over Elements

You can iterate over the elements of a Vector using traditional loops or enhanced for loops.

for (int i = 0; i < vector.size(); i++) { System.out.println(vector.get(i)); } // Enhanced for loop for (Integer num : vector) { System.out.println(num); }


Unlike ArrayList, Vector is synchronized, meaning it is thread-safe. However, this comes with a performance cost, so unless you need thread safety, it's often better to use ArrayList.

Vector<Integer> synchronizedVector = new Vector<>();

Other Methods

Vector class provides several other useful methods such as size(), isEmpty(), contains(), clear(), indexOf(), lastIndexOf(), etc.

System.out.println(vector.size()); // Prints the number of elements in the vector System.out.println(vector.isEmpty()); // Checks if the vector is empty System.out.println(vector.contains(20)); // Checks if the vector contains 20 vector.clear(); // Clears all elements from the vector

Here's a comprehensive example illustrating many of the mentioned functionalities:

import java.util.Vector; public class Main { public static void main(String[] args) { Vector<Integer> vector = new Vector<>(); vector.add(10); vector.add(20); vector.add(30); System.out.println("Size: " + vector.size()); // Output: Size: 3 System.out.println("Elements:"); for (Integer num : vector) { System.out.println(num); } vector.remove(0); System.out.println("Size after removal: " + vector.size()); // Output: Size after removal: 2 System.out.println("Is 20 present? " + vector.contains(20)); // Output: Is 20 present? true } }
//Output: Size: 3 Elements: 10 20 30 Size after removal: 2 Is 20 present? true

This example demonstrates the creation of a Vector, addition and removal of elements, checking size, iteration, and checking for element presence.

Alternatives to Vector

  1. ArrayList: For most cases where thread safety isn't a requirement, ArrayList offers better performance due to its non-synchronized nature.
  2. ConcurrentHashMap: If you need a thread-safe map-like structure, ConcurrentHashMap is a good option.


Vector is a dynamic array-like data structure provided by the java.util package. It automatically resizes itself as elements are added or removed, provides synchronized methods for thread safety, and offers functionalities such as adding, accessing, and removing elements, making it suitable for scenarios requiring dynamic resizing with thread-safe operations. However, its synchronization overhead may lead to performance penalties compared to alternatives like ArrayList.