Vector Class

Overview

• Synchronized (thread-safe) implementation of dynamic array
• Legacy class from Java 1.0
• Implements List interface
• Grows automatically as needed

Basic Vector Operations

import java.util.*;
public class VectorBasicExample {
public static void main(String[] args) {
// Creating Vector
Vector<String> vector = new Vector<>();
// Adding elements
vector.add("Apple");
vector.add("Banana");
vector.addElement("Orange"); // Legacy method
vector.add(1, "Mango"); // Insert at specific position
System.out.println("Vector: " + vector);
// Accessing elements
System.out.println("Element at index 0: " + vector.get(0));
System.out.println("First element: " + vector.firstElement());
System.out.println("Last element: " + vector.lastElement());
// Size and capacity
System.out.println("Size: " + vector.size());
System.out.println("Capacity: " + vector.capacity());
// Checking existence
System.out.println("Contains 'Apple': " + vector.contains("Apple"));
System.out.println("Index of 'Banana': " + vector.indexOf("Banana"));
}
}

Vector Constructors

import java.util.*;
public class VectorConstructors {
public static void main(String[] args) {
// 1. Default constructor (capacity: 10)
Vector<Integer> v1 = new Vector<>();
System.out.println("Default capacity: " + v1.capacity());
// 2. With initial capacity
Vector<Integer> v2 = new Vector<>(20);
System.out.println("Capacity 20: " + v2.capacity());
// 3. With initial capacity and capacity increment
Vector<Integer> v3 = new Vector<>(10, 5);
System.out.println("Initial capacity: " + v3.capacity());
// Add elements to see capacity growth
for (int i = 0; i < 15; i++) {
v3.add(i);
}
System.out.println("After adding 15 elements, capacity: " + v3.capacity());
// 4. From existing collection
List<String> list = Arrays.asList("A", "B", "C");
Vector<String> v4 = new Vector<>(list);
System.out.println("Vector from collection: " + v4);
}
}

Vector Capacity Management

import java.util.*;
public class VectorCapacityExample {
public static void main(String[] args) {
Vector<Integer> vector = new Vector<>(5, 3); // Initial: 5, Increment: 3
System.out.println("Initial capacity: " + vector.capacity());
System.out.println("Size: " + vector.size());
// Add elements to trigger capacity increase
for (int i = 1; i <= 10; i++) {
vector.add(i);
System.out.println("Added " + i + " - Size: " + vector.size() + 
", Capacity: " + vector.capacity());
}
// Capacity management methods
vector.ensureCapacity(20); // Ensure minimum capacity
System.out.println("After ensureCapacity(20): " + vector.capacity());
vector.trimToSize(); // Trim to current size
System.out.println("After trimToSize(): " + vector.capacity());
}
}

Vector Enumeration (Legacy)

import java.util.*;
public class VectorEnumerationExample {
public static void main(String[] args) {
Vector<String> vector = new Vector<>();
vector.add("Java");
vector.add("Python");
vector.add("C++");
vector.add("JavaScript");
// Using Enumeration (legacy)
System.out.println("Using Enumeration:");
Enumeration<String> enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
System.out.println(enumeration.nextElement());
}
// Using Iterator (modern)
System.out.println("\nUsing Iterator:");
Iterator<String> iterator = vector.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
// Using for-each loop
System.out.println("\nUsing for-each:");
for (String language : vector) {
System.out.println(language);
}
// Using forEach with lambda (Java 8+)
System.out.println("\nUsing forEach with lambda:");
vector.forEach(lang -> System.out.println(lang));
}
}

Vector vs ArrayList

import java.util.*;
public class VectorVsArrayList {
public static void main(String[] args) {
// Vector is synchronized
Vector<String> vector = new Vector<>();
vector.add("A");
vector.add("B");
// ArrayList is not synchronized
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("A");
arrayList.add("B");
// Making ArrayList synchronized
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// Performance comparison
int size = 100000;
// Vector performance
long startTime = System.currentTimeMillis();
Vector<Integer> v = new Vector<>();
for (int i = 0; i < size; i++) {
v.add(i);
}
long vectorTime = System.currentTimeMillis() - startTime;
// ArrayList performance
startTime = System.currentTimeMillis();
ArrayList<Integer> al = new ArrayList<>();
for (int i = 0; i < size; i++) {
al.add(i);
}
long arrayListTime = System.currentTimeMillis() - startTime;
System.out.println("Vector time: " + vectorTime + "ms");
System.out.println("ArrayList time: " + arrayListTime + "ms");
}
}

Thread-Safe Vector Operations

import java.util.*;
public class VectorThreadSafety {
public static void main(String[] args) throws InterruptedException {
Vector<Integer> sharedVector = new Vector<>();
// Create multiple threads that modify the vector
Thread writer1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
sharedVector.add(i);
}
});
Thread writer2 = new Thread(() -> {
for (int i = 1000; i < 2000; i++) {
sharedVector.add(i);
}
});
Thread reader = new Thread(() -> {
// Safe to iterate even while other threads modify
synchronized (sharedVector) {
Iterator<Integer> it = sharedVector.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
}
});
writer1.start();
writer2.start();
Thread.sleep(100); // Let writers add some elements
reader.start();
writer1.join();
writer2.join();
reader.join();
System.out.println("\nFinal size: " + sharedVector.size());
}
}

Stack Class

Overview

• LIFO (Last-In-First-Out) data structure
• Extends Vector class
• Synchronized (thread-safe)
• Legacy class - Consider using Deque instead for new code

Basic Stack Operations

import java.util.*;
public class StackBasicExample {
public static void main(String[] args) {
// Creating Stack
Stack<String> stack = new Stack<>();
// Pushing elements (adding to top)
stack.push("First");
stack.push("Second");
stack.push("Third");
stack.push("Fourth");
System.out.println("Stack: " + stack);
// Peeking (view top element without removal)
System.out.println("Top element: " + stack.peek());
// Popping elements (removing from top)
System.out.println("Popped: " + stack.pop());
System.out.println("Popped: " + stack.pop());
System.out.println("Stack after pops: " + stack);
// Searching (returns 1-based position from top)
System.out.println("Position of 'First': " + stack.search("First"));
System.out.println("Position of 'Second': " + stack.search("Second")); // -1, not found
// Checking if empty
System.out.println("Is stack empty? " + stack.isEmpty());
// Emptying the stack
while (!stack.isEmpty()) {
System.out.println("Popping: " + stack.pop());
}
System.out.println("Stack empty? " + stack.isEmpty());
}
}

Stack Use Cases

1. Expression Evaluation

import java.util.*;
public class ExpressionEvaluation {
public static boolean isBalanced(String expression) {
Stack<Character> stack = new Stack<>();
for (char ch : expression.toCharArray()) {
if (ch == '(' || ch == '[' || ch == '{') {
stack.push(ch);
} else if (ch == ')' || ch == ']' || ch == '}') {
if (stack.isEmpty()) return false;
char top = stack.pop();
if ((ch == ')' && top != '(') ||
(ch == ']' && top != '[') ||
(ch == '}' && top != '{')) {
return false;
}
}
}
return stack.isEmpty();
}
public static void main(String[] args) {
String[] expressions = {
"((2+3)*5)",
"{[()]}",
"((2+3)*5",
"[(])"
};
for (String expr : expressions) {
System.out.println(expr + " is balanced: " + isBalanced(expr));
}
}
}

2. Undo/Redo Functionality

import java.util.*;
class TextEditor {
private Stack<String> undoStack = new Stack<>();
private Stack<String> redoStack = new Stack<>();
private String currentText = "";
public void write(String text) {
undoStack.push(currentText);
currentText += text;
redoStack.clear(); // Clear redo stack on new write
System.out.println("Text: " + currentText);
}
public void undo() {
if (!undoStack.isEmpty()) {
redoStack.push(currentText);
currentText = undoStack.pop();
System.out.println("Undo - Text: " + currentText);
} else {
System.out.println("Nothing to undo");
}
}
public void redo() {
if (!redoStack.isEmpty()) {
undoStack.push(currentText);
currentText = redoStack.pop();
System.out.println("Redo - Text: " + currentText);
} else {
System.out.println("Nothing to redo");
}
}
}
public class UndoRedoExample {
public static void main(String[] args) {
TextEditor editor = new TextEditor();
editor.write("Hello");
editor.write(" World");
editor.write("!");
editor.undo();
editor.undo();
editor.redo();
editor.redo();
}
}

3. Browser History

import java.util.*;
class Browser {
private Stack<String> backStack = new Stack<>();
private Stack<String> forwardStack = new Stack<>();
private String currentPage = "home";
public void visit(String url) {
backStack.push(currentPage);
currentPage = url;
forwardStack.clear(); // Clear forward stack on new visit
System.out.println("Visited: " + currentPage);
}
public void back() {
if (!backStack.isEmpty()) {
forwardStack.push(currentPage);
currentPage = backStack.pop();
System.out.println("Back to: " + currentPage);
} else {
System.out.println("Can't go back");
}
}
public void forward() {
if (!forwardStack.isEmpty()) {
backStack.push(currentPage);
currentPage = forwardStack.pop();
System.out.println("Forward to: " + currentPage);
} else {
System.out.println("Can't go forward");
}
}
public String getCurrentPage() {
return currentPage;
}
}
public class BrowserHistoryExample {
public static void main(String[] args) {
Browser browser = new Browser();
browser.visit("google.com");
browser.visit("github.com");
browser.visit("stackoverflow.com");
browser.back();
browser.back();
browser.forward();
browser.visit("leetcode.com");
browser.forward(); // Can't go forward after new visit
}
}

Stack with Custom Objects

import java.util.*;
class Book {
private String title;
private String author;
private int year;
public Book(String title, String author, int year) {
this.title = title;
this.author = author;
this.year = year;
}
public String getTitle() { return title; }
public String getAuthor() { return author; }
public int getYear() { return year; }
@Override
public String toString() {
return title + " by " + author + " (" + year + ")";
}
}
public class StackWithObjects {
public static void main(String[] args) {
Stack<Book> bookStack = new Stack<>();
// Push books onto stack
bookStack.push(new Book("Effective Java", "Joshua Bloch", 2018));
bookStack.push(new Book("Clean Code", "Robert Martin", 2008));
bookStack.push(new Book("Head First Java", "Kathy Sierra", 2005));
System.out.println("Books in stack (LIFO order):");
// Process books in LIFO order
while (!bookStack.isEmpty()) {
Book book = bookStack.pop();
System.out.println("Processing: " + book);
}
}
}

Modern Alternative to Stack

import java.util.*;
public class DequeAsStack {
public static void main(String[] args) {
// Using ArrayDeque as stack (recommended for new code)
Deque<String> stack = new ArrayDeque<>();
// Push operations
stack.push("First");
stack.push("Second");
stack.push("Third");
System.out.println("Stack: " + stack);
// Peek operation
System.out.println("Top element: " + stack.peek());
// Pop operations
System.out.println("Popped: " + stack.pop());
System.out.println("Popped: " + stack.pop());
System.out.println("Remaining: " + stack);
// Additional Deque operations
stack.addLast("New Last"); // Equivalent to push for stack behavior
stack.addFirst("New First");
System.out.println("After additions: " + stack);
}
}

Complete Stack Implementation Example

import java.util.*;
public class CompleteStackExample {
// Method to reverse a list using stack
public static <T> List<T> reverseList(List<T> list) {
Stack<T> stack = new Stack<>();
List<T> reversed = new ArrayList<>();
// Push all elements onto stack
for (T element : list) {
stack.push(element);
}
// Pop elements to get reversed order
while (!stack.isEmpty()) {
reversed.add(stack.pop());
}
return reversed;
}
// Method to check palindrome using stack
public static boolean isPalindrome(String str) {
Stack<Character> stack = new Stack<>();
String cleanStr = str.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
// Push first half of characters
for (int i = 0; i < cleanStr.length() / 2; i++) {
stack.push(cleanStr.charAt(i));
}
// Start from middle (adjust for odd length)
int startIndex = cleanStr.length() / 2;
if (cleanStr.length() % 2 != 0) {
startIndex++;
}
// Compare with second half
for (int i = startIndex; i < cleanStr.length(); i++) {
if (stack.pop() != cleanStr.charAt(i)) {
return false;
}
}
return true;
}
public static void main(String[] args) {
// Test reverse list
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Diana");
System.out.println("Original: " + names);
System.out.println("Reversed: " + reverseList(names));
// Test palindrome
String[] testStrings = {"racecar", "hello", "A man a plan a canal Panama"};
for (String str : testStrings) {
System.out.println("'" + str + "' is palindrome: " + isPalindrome(str));
}
}
}

Key Points to Remember

Vector:

• Synchronized - Thread-safe but slower than ArrayList
• Dynamic array - Grows automatically
• Legacy class - Use ArrayList for better performance in single-threaded environments
• Capacity management - Can specify initial capacity and increment

Stack:

• LIFO principle
• Extends Vector - Inherits all Vector methods
• Legacy class - Use Deque interface with ArrayDeque for better performance
• Common use cases: Expression evaluation, undo/redo, backtracking

When to Use:

• Vector: When thread safety is needed and performance is not critical
• Stack: When LIFO behavior is required in legacy code
• Alternatives: Use Collections.synchronizedList() or CopyOnWriteArrayList for thread safety, and ArrayDeque for stack operations

Both Vector and Stack are legacy classes and generally not recommended for new code, but they're important to understand for maintaining existing applications.