Vector and Stack in Java – Legacy Classes Demystified

By Ashwani Kumar Last updated: 07 Aug 2025

While Vector and Stack are part of the original Java Collections Framework, they are considered legacy classes today. Understanding their internals, thread-safety guarantees, and when (if ever) to use them is crucial for maintaining and refactoring old Java systems.

🗂️ What are Vector and Stack?

Vector

A synchronized, growable array that implements the List interface. It was part of Java 1.0 and later retrofitted to implement List in Java 2.

Stack

A subclass of Vector that implements a LIFO (Last-In-First-Out) stack structure.

Vector<String> vector = new Vector<>();
vector.add("Java");

Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
stack.pop(); // 20

🛠️ Internal Working

Vector Internals

Backed by an Object[] array like ArrayList
Grows by doubling capacity (2x), unlike ArrayList's 1.5x
All methods are synchronized

elementData = Arrays.copyOf(elementData, newCapacity);

Stack Internals

No additional fields; inherits all from Vector
Adds only 5 methods: push(), pop(), peek(), empty(), search()

⏱️ Performance Benchmarks

Operation	Vector	Stack (via Vector)
`add(E)`	O(1)	O(1)
`get(int)`	O(1)	O(1)
`remove(int)`	O(n)	O(n)
`push(E)`	O(1)	O(1)
`pop()`	O(1)	O(1)
Synchronization	Yes	Yes

✅ Use Cases in Legacy Systems

Codebases before Java 1.2 that heavily used synchronized collections
Stack used for recursive algorithms, backtracking, and compiler implementations
Vector used in GUI frameworks (e.g., AWT) historically

🔁 Vector vs ArrayList vs CopyOnWriteArrayList

Feature	Vector	ArrayList	CopyOnWriteArrayList
Thread-Safe	Yes	No	Yes (lock-free reads)
Performance	Slower	Fast	Slow (writes expensive)
Resize Strategy	Double	1.5x	Double
Preferred For	Legacy Code	Modern Single-threaded	Concurrent Reads

🔄 Stack vs Deque (Modern Stack Replacement)

Feature	Stack	Deque (`ArrayDeque`)
Thread-safe	No	No
Push/Pop	Yes	Yes
Performance	Slower	Faster
Preferred	❌ Avoid	✅ Use Instead

Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);
stack.push(2);
System.out.println(stack.pop()); // 2

❌ Anti-patterns and Refactoring

❌ Using Stack in New Code

Stack<String> stack = new Stack<>();

✅ Replace with:

Deque<String> stack = new ArrayDeque<>();

❌ Using Vector for thread-safety

Vector<String> list = new Vector<>();

✅ Use:

List<String> syncList = Collections.synchronizedList(new ArrayList<>());

🧬 Stream API Example with Vector

Vector<String> names = new Vector<>();
names.add("Alice");
names.add("Bob");

List<String> result = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

📌 What's New in Java Versions?

Java 8

Stream support added to all collections, including legacy ones

Java 9

Introduced immutable collection factories: List.of(), etc.

Java 10

var for local variable type inference

Java 11

Performance tuning and small optimizations

Java 17 & 21

Better concurrent collection alternatives (e.g., ConcurrentLinkedDeque)

🔄 Legacy Refactor Example

Before:

Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
stack.pop();

After:

Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);
stack.push(2);
stack.pop();

🧠 Real-World Analogy

Think of a Stack like a pile of books. You can only remove the top one. Vector is like a locker with double locks — secure, but slow to access compared to modern shelves.

❓ FAQ – Advanced Questions

Is Vector obsolete?
- It's considered legacy; use ArrayList + sync wrapper instead.
Is Stack still used?
- No. Prefer Deque for stack operations.
How does Vector handle resizing?
- It doubles the internal array size.
Why was Vector synchronized by default?
- It predates the Java Collections Framework, which didn’t separate concurrency.
Is Stack backed by an array or linked nodes?
- Array, via Vector.

How to convert Vector to ArrayList?

List<String> list = new ArrayList<>(vector);

What is the alternative to Vector for concurrency?
- CopyOnWriteArrayList, Collections.synchronizedList()
Can Stack be used as a Queue?
- No. Use Deque.
Do Vector and Stack support fail-fast iterators?
- Yes, like all Java Collections.
What package are they in?

java.util

🏁 Conclusion and Key Takeaways

Avoid using Vector and Stack in modern applications unless required for legacy compatibility.
Replace with ArrayList, ArrayDeque, or concurrent variants for better performance and scalability.
Use knowledge of these legacy classes to refactor old systems safely.

🔍 Pro Tip: Know your tools — legacy classes aren’t evil, but better options exist for today’s development needs.