Vector vs ArrayList in Java

By: Rajesh P.S.

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:

Feature

ArrayList

Vector

Synchronization

Not synchronized

Synchronized

Resizing

Increases by 50% of current size

Doubles its size (100% increase)

Legacy

Modern class (introduced in Java 1.2)

Legacy class

Traversal

Uses Iterator interface only

Uses both Iterator and Enumeration interfaces

Synchronization

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.
Vector: Synchronized. All methods of Vector are synchronized, ensuring thread safety. This makes Vector slower than ArrayList but suitable for multithreaded applications.

Example:

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

Resizing

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.
Vector: Doubles its size (100% increase) when capacity is reached. This can lead to slightly less frequent resizing but might waste some memory initially.

Example

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)

Performance

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.
Vector: Due to its synchronized nature, Vector might incur performance penalties, especially in scenarios where synchronization is not required.

Growth Rate

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

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

Traversal

ArrayList: Only uses the Iterator interface for traversing elements.
Vector: Supports both Iterator and the older Enumeration interface for iteration.

Examples:

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

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

Conclusion

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.

Next > What is the difference between ArrayList and LinkedList?

Related Topics

More Related Topics.....