Sự khác biệt giữa ArrayList và Vector trong Java

Cả ArrayList và Vector đều triển khai interface List, dùng mảng động (dynamic array) bên dưới, giữ thứ tự chèn. Nhưng có khác biệt quan trọng về thread-safety, hiệu năng, và legacy.

Bảng so sánh

STT	Tiêu chí	ArrayList	Vector
1	Đồng bộ (Synchronization)	Không synchronized (non-thread-safe). Nhanh hơn.	Synchronized (thread-safe). Mọi public method đều synchronized.
2	Tăng dung lượng (Growth)	Tăng 50% kích thước hiện tại (1.5x).	Tăng 100% (gấp đôi - 2x).
3	Legacy	Không (Collections Framework từ JDK 1.2).	Có (từ JDK 1.0, trước Collections Framework).
4	Hiệu năng	Nhanh hơn do không synchronized overhead.	Chậm hơn do synchronized trên mọi method.
5	Duyệt (Iteration)	Chỉ `Iterator` (fail-fast).	`Iterator` (fail-fast) VÀ `Enumeration` (legacy, không fail-fast).
6	Thiết lập capacity	Constructor `ArrayList(int initialCapacity)`.	Constructor `Vector(int initialCapacity, int capacityIncrement)` - có thể tùy increment.
7	Phương thức legacy	Không.	Có: `addElement`, `elementAt`, `setSize`, `capacity`...

Ví dụ code

import java.util.ArrayList;
import java.util.Vector;
import java.util.List;

public class JavaTester {
    public static void main(String args[]) {
        List arrayList = new ArrayList<>();
        arrayList.add("A");
        arrayList.add("B");
        arrayList.add("C");
        arrayList.add("D");
        
        List vector = new Vector<>();
        vector.add("A");
        vector.add("B");
        vector.add("C");
        vector.add("D");
        
        System.out.println("ArrayList: " + arrayList);
        System.out.println("Vector: " + vector);
        
        // Demo Enumeration (Vector only)
        java.util.Enumeration e = ((Vector) vector).elements();
        System.out.print("Vector Enumeration: ");
        while (e.hasMoreElements()) {
            System.out.print(e.nextElement() + " ");
        }
    }
}

Kết quả

ArrayList: [A, B, C, D]
Vector: [A, B, C, D]
Vector Enumeration: A B C D

Khi nào dùng nào?

ArrayList	Vector
Đa số trường hợp (single-threaded). Cần hiệu năng cao. Muốn kiểm soát đồng bộ hóa thủ công (synchronized block, Collections.synchronizedList, CopyOnWriteArrayList). Code hiện đại, non-legacy.	Code legacy cũ (JDK 1.0-1.1) cần maintain. Cần thread-safe đơn giản, ít tranh chấp ( ít ghi, nhiều đọc). Cần tùy chỉnh capacityIncrement. Cần Enumeration cho API cũ.

Thread-safe Alternative hiện đại

Thay vì Vector (synchronized toàn bộ method), hãy dùng:

Collections.synchronizedList(new ArrayList<>()) - synchronized mỗi method, giống Vector nhưng flexible hơn.
CopyOnWriteArrayList - thread-safe, iterator không fail-fast, phù hợp đọc nhiều, ghi ít (snapshot).
List<T> list = new ArrayList<>(); + synchronized(list) { ... } - kiểm soát granularity.

Lưu ý

Vector không deprecated nhưng không khuyến khích cho code mới.
Stackextends Vector cũng legacy, dùng Deque<T> stack = new ArrayDeque<>() thay thế.
Cả hai đều implement RandomAccess - truy cập index O(1).