Vector vs ArrayList in Java

ArrayList and Vector are both classes provided by the Java Collections Framework that implement the List interface and are used to store a collection of elements. They have several similarities but also some differences:

Here's a table summarizing the key differences:

Not synchronized
Increases by 50% of current size
Doubles its size (100% increase)
Modern class (introduced in Java 1.2)
Legacy class
Uses Iterator interface only
Uses both Iterator and Enumeration interfaces


  1. ArrayList: Not synchronized. This means multiple threads can access and modify an ArrayList simultaneously, which can lead to data inconsistencies. It's faster for single-threaded environments.
  2. Vector: Synchronized. All methods of Vector are synchronized, ensuring thread safety. This makes Vector slower than ArrayList but suitable for multithreaded applications.
// ArrayList in a single-threaded environment (safe) ArrayList<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); // This might cause issues in a multithreaded environment // for Vector Vector<Integer> accountIds = new Vector<>(); accountIds.add(123); accountIds.add(456);


  1. ArrayList: When the number of elements exceeds the current capacity, ArrayList increases its size by 50% of the current size. This helps to minimize unnecessary memory allocation but might require more resizing operations for frequently growing lists.
  2. Vector: Doubles its size (100% increase) when capacity is reached. This can lead to slightly less frequent resizing but might waste some memory initially.
ArrayList<Integer> numbers = new ArrayList<>(2); // Initial capacity of 2 numbers.add(1); numbers.add(2); numbers.add(3); // Triggers resize (capacity becomes 3) Vector<String> colors = new Vector<>(4); // Initial capacity of 4 colors.add("Red"); colors.add("Green"); colors.add("Blue"); colors.add("Yellow"); // Triggers resize (capacity becomes 8)


  1. ArrayList: Because ArrayList is not synchronized, it generally offers better performance in single-threaded environments compared to Vector. However, in multithreaded environments, ArrayList might require explicit synchronization, which can introduce overhead.
  2. Vector: Due to its synchronized nature, Vector might incur performance penalties, especially in scenarios where synchronization is not required.

Growth Rate

  1. ArrayList: By default, ArrayList increases its size by 50% when it needs to grow. This means that if the current capacity is not enough to accommodate new elements, it will increase its capacity by half of the current capacity.
  2. Vector: Vector doubles its size when it needs to grow. This means that if the current capacity is not enough, Vector will double its capacity.

Legacy vs. Modern

  1. ArrayList: Introduced in Java 1.2 and part of the Java Collections Framework. It's the preferred choice for most modern Java development.
  2. Vector: A legacy class present since earlier versions of Java. It's less commonly used due to its synchronization overhead and some legacy methods.


  1. ArrayList: Only uses the Iterator interface for traversing elements.
  2. Vector: Supports both Iterator and the older Enumeration interface for iteration.
import java.util.ArrayList; import java.util.Vector; public class ArrayListVsVector { public static void main(String[] args) { // Example of ArrayList ArrayList<Integer> arrayList = new ArrayList<>(); arrayList.add(1); arrayList.add(2); arrayList.add(3); // No need for synchronization in single-threaded environment System.out.println("ArrayList: " + arrayList); // Example of Vector Vector<Integer> vector = new Vector<>(); vector.add(1); vector.add(2); vector.add(3); // Thread-safe due to synchronization System.out.println("Vector: " + vector); } }

In the above example, both ArrayList and Vector store integers. However, Vector ensures thread safety due to its synchronized nature, while ArrayList does not. This difference becomes significant in multithreaded scenarios.

Choosing Between ArrayList and Vector

  1. In most cases, ArrayList is the better choice due to its performance benefits in single-threaded environments.
  2. Use Vector only when thread safety is a critical requirement, and explicit synchronization with Collections.synchronizedList is not feasible for ArrayList.


ArrayList and Vector are both classes in Java used to store collections of elements, but they differ in their synchronization behavior, resizing strategy, and legacy status. ArrayList is not synchronized, grows by 50% of its current size when needed, and is a modern class introduced in Java 1.2, while Vector is synchronized, doubles its size when resizing, and is a legacy class introduced in Java 1.0.