Vector & Stack

#Introduction

Vector and Stack are considered legacy collection classes, but they are still frequently asked in interviews because they help interviewers evaluate your understanding of the evolution of the Java Collections Framework, thread safety, and legacy vs modern APIs.

Although you may rarely use them in new applications, you must know how they work and why modern alternatives are preferred.

#History of Vector

Before the Java Collections Framework (JDK 1.2), Java provided a few collection-like classes. One of them was Vector.

After JDK 1.2, Vector was modified to implement the List interface. That means today it behaves like a normal List while retaining its original synchronized behaviour.

#What is Vector?

Vector is a synchronized, resizable array implementation of the List interface.

Package:

java.util.Vector

Declaration:

public class Vector<E>
        extends AbstractList<E>
        implements List<E>,
                   RandomAccess,
                   Cloneable,
                   Serializable

Like ArrayList, Vector implements RandomAccess because internally it also uses an array.

#Characteristics of Vector

• Maintains insertion order
• Allows duplicates
• Allows null values
• Dynamic resizing
• Thread-safe
• Slower than ArrayList
• Legacy class

#Internal Structure

Exactly like ArrayList, Vector stores elements inside:

Object[] elementData;

#Why is Vector Thread-Safe?

Interview favourite. Every public method is synchronized:

public synchronized boolean add(E e)

Meaning: only one thread can modify the Vector at a time.

#Synchronization Cost

vector.add("Java");

#Creating a Vector

Default Constructor

Vector<Integer> vector = new Vector<>();

Default capacity: 10.

Initial Capacity

Vector<Integer> vector = new Vector<>(100);

Capacity: 100.

Capacity Increment

A unique feature of Vector.

Vector<Integer> vector = new Vector<>(10, 5);

Initial capacity 10, capacity increment 5.

#Growth Algorithm

Interview favourite. If no capacity increment is specified, Vector doubles its capacity.

#Size vs Capacity

Vector<Integer> vector = new Vector<>();

After adding 5 elements: Size = 5, Capacity = 10 — exactly like ArrayList.

#Important Methods

Vector Example

Vector<String> vector = new Vector<>();
vector.add("Java");
vector.add("Spring");
vector.add("Docker");
System.out.println(vector);

[Java, Spring, Docker]

#Enumeration

Before Iterator, Java used Enumeration.

Enumeration<String> e = vector.elements();

while (e.hasMoreElements()) {
    System.out.println(e.nextElement());
}

Enumeration is still supported for backward compatibility.

Enumeration vs Iterator

#Stack

What is Stack?

Stack extends Vector.

public class Stack<E> extends Vector<E>

Meaning: every Vector method is available inside Stack.

LIFO Principle

Stack follows LIFO — Last In, First Out.

#Stack Operations

search() Example

Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
stack.push(30);
System.out.println(stack.search(20));

2

Stack Example

Stack<String> stack = new Stack<>();
stack.push("Java");
stack.push("Spring");
stack.push("AWS");
System.out.println(stack.pop());
System.out.println(stack.peek());

AWS
Spring

#Why is Stack Legacy?

Interview favourite. Because it extends Vector, every operation is synchronized — extra overhead. Modern Java recommends ArrayDeque instead.

ArrayDeque vs Stack

Why is ArrayDeque Preferred?

• Faster
• No synchronization overhead
• Better memory usage
• Designed specifically for Queue and Stack operations

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

stack.push(10);
stack.push(20);

System.out.println(stack.pop());

20

#Vector vs ArrayList

#Time Complexity