Vector

// ── Vector — all methods are synchronised: ───────────────────────────
Vector<String> vector = new Vector<>();

// Legacy API (pre-Collections Framework):
vector.addElement("Alice");          // same as add()
vector.addElement("Bob");
String elem   = vector.elementAt(0); // same as get(0)
int    size   = vector.size();
boolean found = vector.contains("Alice");
vector.removeElement("Bob");         // same as remove("Bob")
vector.removeAllElements();          // same as clear()

Enumeration<String> e = vector.elements(); // legacy Enumeration (pre-Iterator)
while (e.hasMoreElements()) {
    System.out.println(e.nextElement());
}

// Modern List API also works (List interface retrofit):
vector.add("Charlie");
vector.add("Dave");
String s = vector.get(0);             // same as elementAt(0)
vector.remove("Charlie");             // same as removeElement("Charlie")
vector.set(0, "Updated");
for (String item : vector) { ... }   // for-each via Iterable

// ── Capacity model — similar to ArrayList: ────────────────────────────
// Vector has a capacityIncrement parameter:
Vector<Integer> v = new Vector<>(10, 5);  // initial capacity 10, grow by 5
// Unlike ArrayList (grows by 50%), Vector grows by capacityIncrement
// or doubles if capacityIncrement is 0.

// ── Why Vector is slow: ───────────────────────────────────────────────
// Every method: synchronized (method) { ... }
// Even size() acquires a lock:
// public synchronized int size() { return elementCount; }
// In a single-threaded program, this lock is uncontested but still has
// overhead from the monitor acquisition machinery.

// ── Thread-safe but not enough: ──────────────────────────────────────
Vector<Integer> shared = new Vector<>();
// Still not safe for compound operations:
if (shared.isEmpty()) {
    // Another thread could add an element here
    shared.remove(0);   // IndexOutOfBoundsException possible!
}
// Both isEmpty() and remove() are synchronised individually,
// but there is no lock held between the two calls.

// ── Comparison of thread-safe list options: ──────────────────────────

// Option 1: Vector (legacy)
Vector<String> vector = new Vector<>();
// All methods synchronised — each acquires this's intrinsic lock
// Iteration still requires external synchronisation:
synchronized (vector) {
    for (String s : vector) {
        System.out.println(s);   // must sync iteration
    }
}

// Option 2: Collections.synchronizedList (modern wrapper)
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// Equivalent semantics to Vector, cleaner API:
synchronized (syncList) {
    for (String s : syncList) {
        System.out.println(s);   // still must sync iteration
    }
}

// Option 3: CopyOnWriteArrayList (read-heavy concurrent)
CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<>();
cowList.add("Alice");   // creates a copy of the internal array — expensive
cowList.add("Bob");     // another copy
// But reads are completely lock-free:
for (String s : cowList) {
    System.out.println(s);   // no synchronisation needed — iterates a snapshot
}

// ── Performance characteristics: ──────────────────────────────────────
//
//                    ArrayList   Vector     SyncList   COWArrayList
// ─────────────────  ─────────   ───────    ────────   ────────────
// Single thread      Fastest     Slow       Slow       Slow for write
// Read (multi-thd)   UNSAFE      Safe       Safe       Fastest
// Write (multi-thd)  UNSAFE      Safe       Safe       Slowest (copy)
// Best use case      Default     Legacy     Replace    Read-heavy
//
// ── Migrating from Vector to ArrayList: ──────────────────────────────
// Single-threaded: safe direct replacement
Vector<String> oldCode = new Vector<>();
List<String> newCode = new ArrayList<>();

// Multi-threaded: requires analysis
// If synchronisation was relied upon:
List<String> safeMigration =
    Collections.synchronizedList(new ArrayList<>());
// or CopyOnWriteArrayList for read-heavy
CopyOnWriteArrayList<String> readHeavy = new CopyOnWriteArrayList<>();