Vector Class in Java

Last Updated : 06 Aug, 2025

Vector is a resizable array in Java, found in the java.util package. It is part of the Collection Framework and works like an ArrayList, but it is synchronized, meaning it is safe to use in multi-threaded programs. However, this makes it a bit slower than ArrayList.

Key Features of Vector

It expands as elements are added.
The Vector class is synchronized in nature means it is thread-safe by default.
Like an ArrayList, it maintains insertion order.
It allows duplicates and nulls.
It implements List, RandomAccess, Cloneable and Serializable.

Vector Class Declaration

Java

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

Here, E is the type of element.

Example: Java Program Implementing Vector

Java

import java.util.Vector;

public class Geeks
{
    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);
        }
    }
}

Output

1
0
3

Vector Capacity in Java

When a Vector is created using the default constructor, it is initialized with a default capacity of 10. This means it can hold up to 10 elements before needing to grow in size. If the number of elements exceeds the current capacity, the Vector automatically increases its capacity.

Vector<String> vec = new Vector<>();
System.out.println("Default Capacity: " + vec.capacity()); // Output: 10

Formula to calculate new capacity

newCapacity = oldCapacity * 2

Example:

Java

import java.util.Vector;

public class VectorDoublingExample {
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<>(2); // initial capacity = 2
        System.out.println("Initial capacity: " + vector.capacity());

        // Add elements to trigger capacity increase
        vector.add(10);
        vector.add(20);
        System.out.println("Capacity after adding 2 elements: " + vector.capacity());

        vector.add(30); // Triggers resize (2 → 4)
        System.out.println("Capacity after adding 3rd element: " + vector.capacity());

        vector.add(40);
        vector.add(50); // Triggers resize again (4 → 8)
        System.out.println("Capacity after adding 5 elements: " + vector.capacity());
    }
}

Output

Initial capacity: 2
Capacity after adding 2 elements: 2
Capacity after adding 3rd element: 4
Capacity after adding 5 elements: 8

Constructors of Vector

1. Vector(): Creates a default vector of the initial capacity is 10.

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

2. Vector(int size): Creates a vector whose initial capacity is specified by size.

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

3. Vector(int size, int incr): Creates a vector whose initial capacity is specified by size and increment is specified by incr. It specifies the number of elements to allocate each time a vector is resized upward.

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

4. Vector(Collection c): Creates a vector that contains the elements of collection c.

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

Let us first discuss and implement how to create and use a Vector prior to landing upon the methods of this class.

Example:

Java

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

// Main class
class Geeks {

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

        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);

       
        System.out.println(v);

    
        for (int i = 0; i < v.size(); i++)
            System.out.print(v.get(i) + " ");
    }
}

Output

[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.

Different Operations of Vector Class

1. Adding Elements

To add the elements to the Vector, we use the add() method. This method is overloaded to perform multiple operations based on different parameters. They are listed below as follows:

add(Object): This method is used to add an element at the end of the Vector.
add(int index, Object): This method is used to add an element at a specific index in the Vector.

Example:

Java

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

class Geeks {
    public static void main(String[] arg)
    {
        // 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);

        System.out.println("Vector v1 is " + v1);

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

        // Adding custom elements using add() method
        v2.add(1);
        v2.add(2);
        v2.add(3);
        
        System.out.println("Vector v2 is " + v2);
    }
}

Output

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

2. Updating Elements

To update an element in a Vector, use the set() method. It takes the index and the new element to replace the existing one at that position.

Example:

Java

import java.util.*; 

public class Geeks { 
    
    public static void main(String args[]) 
    { 
        // Creating an empty Vector 
        Vector<Integer> v = new Vector<Integer>(); 

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

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

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

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

        System.out.println("The new Vector is:" + v); 
    } 
}

Output

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. Removing Elements

To remove an element from a Vector, we can use the remove() method. This method is overloaded to perform multiple operations based on different parameters. They are:

remove(Object): This method is used to remove an object from the Vector. If there are multiple such objects, then the first occurrence of the object is removed.
remove(int index): Vector is indexed, so this method takes an integer value which simply removes the element present at that specific index in the Vector. After removing the element, all the elements are moved to the left to fill the space and the indices of the objects are updated.

Example:

Java

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

class Geeks {
  
    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);

        System.out.println("After removal: " + v);
    }
}

Output

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

4. Iterating the Vector

There are multiple ways to iterate through the Vector. The most famous ways are by using the basic for loop in combination with a get() method to get the element at a specific index and the advanced for a loop.

Example:

Java

import java.util.*;

public class Geeks {

    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();

       
        for (String str : v)
            System.out.print(str + " ");
    }
}

Output

Geeks For Geeks 
Geeks For Geeks

Note: Please read to the ArrayList vs Vector class in Java to grasp it better.

Advantages of using Vector in Java

As mentioned before, Vector is synchronized, making it safe to use in a multi-threaded environment.
The size of a Vector can grow or shrink dynamically as elements are added or removed, so you do not have to worry about setting an initial size that will accommodate all elements.
Vector has been part of Java since its inception and is still supported, so it's a good option if you need to work with older Java code that uses Vector.

Disadvantages of using Vector in Java

The synchronization in Vector can lead to slower performance compared to other collection classes, such as ArrayList.
While Vector is still supported, newer Java code is often written using the more modern collection classes, so it may be harder to find examples and support for Vector.
If you don't need the synchronization features of Vector, using it will add unnecessary overhead to your code.

Methods in Vector Class

Method	Description
add(E e)	Appends the specified element to the end of this Vector.
add(int index, E element)	Inserts the specified element at the specified position in this Vector.
addAll(Collection<? extends E> c)	Appends all elements from the given collection to the end of this Vector.
addAll(int index, Collection<? extends E> c)	Insert all of the elements in the specified Collection into this Vector at the specified position.
addElement(E obj)	Adds the specified element to the end, increasing size by one.
capacity()	Returns the current capacity of this vector.
clear()	Removes all of the elements from this Vector.
clone()	Returns a clone of this vector.
contains(Object o)	Returns true if this vector contains the specified element.
containsAll(Collection<?> c)	Returns true if this Vector contains all of the elements in the specified Collection.
copyInto(Object[] anArray)	Copies the components of this vector into the specified array.
elementAt(int index)	Returns the component at the specified index.
elements()	Returns an enumeration of the components of this vector.
ensureCapacity(int minCapacity)	Increases capacity to ensure it can hold at least the specified number of elements.
equals(Object o)	Compares the specified Object with this Vector for equality.
firstElement()	Returns the first component (the item at index 0) of this vector.
forEach(Consumer<? super E> action)	Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.
get(int index)	Returns the element at the specified position in this Vector.
hashCode()	Returns the hash code value for this Vector.
indexOf(Object o)	Returns index of the first occurrence of the element or -1 if not found.
indexOf(Object o, int index)	Returns index of the first occurrence starting from the given index.
insertElementAt(E obj, int index)	Inserts the specified object as a component in this vector at the specified index.
isEmpty()	Tests if this vector has no components.
iterator()	Returns an iterator over the elements in this list in a proper sequence.
lastElement()	Returns the last component of the vector.
lastIndexOf(Object o)	Returns the index of the last occurrence of the element or -1 if not found.
lastIndexOf(Object o, int index)	Returns index of the last occurrence before the given index.
listIterator()	Returns a list iterator over the elements in this list (in proper sequence).
listIterator(int index)	Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
remove(int index)	Removes the element at the specified position in this Vector.
remove(Object o)	Removes the first occurrence of the specified element.
removeAll(Collection<?> c)	Removes from this Vector all of its elements contained in the specified Collection.
removeAllElements()	Removes all components from this vector and sets its size to zero.
removeElement(Object obj)	Removes the first (lowest-indexed) occurrence of the argument from this vector.
removeElementAt(int index)	Deletes the component at the specified index.
removeIf(Predicate<? super E> filter)	Removes all of the elements of this collection that satisfy the given predicate.
removeRange(int fromIndex, int toIndex)	Removes from this list all of the elements whose index is between fromIndex, inclusive and toIndex, exclusive.
replaceAll(UnaryOperator<E> operator)	Replaces each element of this list with the result of applying the operator to that element.
retainAll(Collection<?> c)	Retains only the elements in this Vector contained in the specified Collection.
set(int index, E element)	Replaces the element at the specified position in this Vector with the specified element.
setElementAt(E obj, int index)	Sets the component at the specified index of this vector to be the specified object.
setSize(int newSize)	Sets the size of this vector.
size()	Returns the number of components in this vector.
sort(Comparator<? super E> c)	Sorts this list according to the order induced by the specified Comparator.
spliterator()	Creates a late-binding and fail-fast Spliterator over the elements in this list.
subList(int fromIndex, int toIndex)	Returns a view of the portion of this List between fromIndex, inclusive and toIndex, exclusive.
toArray()	Returns an array containing all of the elements in this Vector in the correct order.
toArray(T[] a)	Returns an array containing all the elements.
toString()	Returns a string representation of this Vector, containing the String representation of each element.
trimToSize()	Trims the capacity of this vector to be the vector's current size.

kartik

Improve

Article Tags :

Practice Tags :

Vector Class in Java

Key Features of Vector

Vector Class Declaration

Vector Capacity in Java

Constructors of Vector

Different Operations of Vector Class

1. Adding Elements

2. Updating Elements

3. Removing Elements

4. Iterating the Vector

Advantages of using Vector in Java

Disadvantages of using Vector in Java

Methods in Vector Class

Similar Reads

Basics

OOPs & Interfaces

Collections

Exception Handling

Java Advanced

Practice Java

Thank You!

What kind of Experience do you want to share?