Why was ArrayList added if Vector already existed?

Adding ArrayList after Vector was driven by the need for an unbounded, resizable array optimized for single-threaded environments. Vector is synchronized, which incurs overhead for locking even when multithreaded access is not needed.

Main differences:

Characteristic	Vector	ArrayList
Synchronization	Synchronized (thread-safe).	Not synchronized (not thread-safe).
Performance	Lower due to synchronization overhead.	Higher in single-threaded scenarios.
Resizing	Doubles in size.	Increases by 50%.
Inherits from	AbstractList, RandomAccess, Cloneable, Serializable.	AbstractList, RandomAccess, Cloneable, Serializable.

Example of using ArrayList for better performance in a single-threaded environment:

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

public class ArrayListExample {

    public static void main(String[] args) {
        List<String> names = new ArrayList<>(); // Using ArrayList
        names.add("Alice");
        names.add("Bob");

        for (String name : names) {
            System.out.println(name);
        }
    }
}

In multithreaded scenarios, it is preferable to use synchronized Vector or wrap ArrayList in a synchronized wrapper using Collections.synchronizedList().

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SynchronizedListExample {

    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        List<String> synchronizedNames = Collections.synchronizedList(names); // Wrapping ArrayList

        // Now synchronizedNames is thread-safe
        synchronizedNames.add("Charlie");
    }
}

Thus, ArrayList was added to provide a more performant alternative to Vector for use in single-threaded programs where synchronization overhead is unnecessary.