Java Collections Framework

Java mein Collections Framework ek bahut hi powerful system hai jo data ko store, retrieve, manipulate aur process karne mein help karta hai. Ye framework List, Set, Queue, aur Map jaise structures provide karta hai, jinke through hum data ko efficiently handle kar sakte hain.

1. List Interface (ArrayList, LinkedList, Vector, Stack)

List ek ordered collection hai jo duplicates allow karta hai. Isme elements index-based retrieve kiye ja sakte hain.

1.1 ArrayList – Dynamic Array Ki Tarah Kaam Karta Hai

• Internally Array use karta hai.
• Fast Random Access (O(1)), kyunki index-based hai.
• Insertion/Deletion slow (O(n)), kyunki shifting hoti hai.
• Best for: Jab humein frequent access chahiye, but kam insertion/deletion karna ho.

Example: ArrayList in Java

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();  // Creating ArrayList
        fruits.add("Apple");  // Adding elements
        fruits.add("Banana");
        fruits.add("Mango");
        fruits.add("Apple");  // Duplicates allowed

        System.out.println(fruits);  // [Apple, Banana, Mango, Apple]
        System.out.println("Element at index 1: " + fruits.get(1));  // Banana

        fruits.remove(2);  // Removes "Mango"
        System.out.println("After removal: " + fruits);  // [Apple, Banana, Apple]

        fruits.set(0, "Grapes");  // Replaces "Apple" with "Grapes"
        System.out.println("After update: " + fruits);  // [Grapes, Banana, Apple]
    }
}

Output:

[Apple, Banana, Mango, Apple]

Element at index 1: Banana

After removal: [Apple, Banana, Apple]

After update: [Grapes, Banana, Apple]

Internal Working of ArrayList

• Default capacity: 10
• Jab full hota hai, toh size grow karta hai:

newCapacity = oldCapacity + (oldCapacity >> 1);  // 50% increase

• Disadvantage: Insertion/Deletion slow hai, kyunki shifting hoti hai.

1.2 LinkedList – Doubly Linked List Implementation

• Internally Nodes use karte hain (prev + next pointers).
• Fast Insertion/Deletion (O(1)), kyunki shifting nahi hoti.
• Slow Random Access (O(n)), kyunki traversal karna padta hai.
• Best for: Jab humein frequent insertion/deletion karna ho.

Example: LinkedList in Java

import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        List<Integer> numbers = new LinkedList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        System.out.println(numbers);  // [10, 20, 30]
        numbers.add(1, 15);  // Insert at index 1
        System.out.println("After insertion: " + numbers);  // [10, 15, 20, 30]

        numbers.remove(2);  // Removes 20
        System.out.println("After removal: " + numbers);  // [10, 15, 30]
    }
}

Output:

[10, 20, 30]

After insertion: [10, 15, 20, 30]

After removal: [10, 15, 30]

Internal Working of LinkedList

• Node Structure:

class Node<E> {
    E data;
    Node<E> next;
    Node<E> prev;
}

• Advantage: Insertion/Deletion fast hai.
• Disadvantage: Random access slow hai.

1.3 Vector – Thread-Safe Legacy Class

• ArrayList ki tarah hai, but synchronized (thread-safe).
• Slow performance, kyunki har operation mein locking overhead hota hai.
• Legacy hai, ab kam use hota hai.

Example: Vector in Java

import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        Vector<String> names = new Vector<>();
        names.add("Rahul");
        names.add("Priya");
        names.add("Amit");

        System.out.println(names);  // [Rahul, Priya, Amit]
        System.out.println("Size: " + names.size());  // 3
        System.out.println("Capacity: " + names.capacity());  // 10 (default)
    }
}

Output:

[Rahul, Priya, Amit]

Size: 3

Capacity: 10

ArrayList vs Vector

1. Thread-Safety (Synchronization):ArrayList thread-safe nahi hoti, matlab agar multiple threads use karein to issues ho sakte hain. Lekin iska fayda ye hai ki yeh zyada fast hoti hai single-threaded environment mein. Wahin Vector thread-safe hoti hai, kyunki uske methods synchronized hote hain. Is wajah se Vector ki performance thodi slow ho jati hai.
2. Growth Strategy (Size Badhane ka Tarika): Jab ArrayList ki internal array full ho jati hai, to yeh apni capacity ko 50% tak increase karti hai. Lekin Vector apni size ko poora double (100%) kar leti hai jab zarurat padti hai.
3. 3. Legacy ya Modern: ArrayList Java 1.2 mein aayi thi aur yeh Java Collections Framework ka part hai. Isliye yeh nayi aur recommended choice hai. Vector ek purani class hai (legacy), aur aaj ke time mein ise use karna avoid kiya jata hai, jab tak synchronization ki strict requirement na ho.

1.4 Stack – LIFO Data Structure (Extends Vector)

• Last-In-First-Out (LIFO) principle pe work karta hai.
• Legacy class hai, better to use ArrayDeque instead.

Example: Stack in Java

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("First");  // Insert
        stack.push("Second");
        stack.push("Third");

        System.out.println(stack);  // [First, Second, Third]
        System.out.println("Top element: " + stack.peek());  // Third

        stack.pop();  // Removes "Third"
        System.out.println("After pop: " + stack);  // [First, Second]
    }
}

Output:

[First, Second, Third]

Top element: Third

After pop: [First, Second]

Stack vs ArrayDeque

• Stack synchronized hai, ArrayDeque nahi.
• ArrayDeque better performance deta hai.

2. Set Interface (HashSet, LinkedHashSet, TreeSet)

Set ek unique elements ka collection hai (no duplicates allowed).

2.1 HashSet – Unordered, Fast Lookup

• Internally HashMap use karta hai.
• No insertion order maintained.
• Best for: Jab humein unique elements chahiye, aur order matter nahi karta.

Example: HashSet in Java

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> cities = new HashSet<>();
        cities.add("Delhi");
        cities.add("Mumbai");
        cities.add("Delhi");  // Duplicate, ignored

        System.out.println(cities);  // [Delhi, Mumbai] (order unpredictable)
        System.out.println("Contains Mumbai? " + cities.contains("Mumbai"));  // true
    }
}

Output:

[First, Second, Third]

Top element: Third

After pop: [First, Second]

Internal Working of HashSet

• Uses HashMap internally:

private transient HashMap<E, Object> map;

• Default capacity: 16, Load Factor: 0.75
• Collision resolution: Chaining (LinkedList/Tree)

2.2 LinkedHashSet – Insertion Order Maintained

• HashSet + LinkedList combination.
• Insertion order maintain karta hai.
• Best for: Jab humein unique elements chahiye, but insertion order bhi preserve karna ho.

Example: LinkedHashSet in Java

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        Set<Integer> numbers = new LinkedHashSet<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(10);  // Duplicate, ignored

        System.out.println(numbers);  // [10, 20] (order maintained)
    }
}

Output:

[10, 20]

Internal Working of LinkedHashSet

• Extends HashSet, uses LinkedHashMap internally.
• Maintains a doubly-linked list for ordering.

2.3 TreeSet – Sorted Order (Red-Black Tree)

• Elements sorted order mein store hote hain.
• Uses Comparable or Comparator for sorting.
• Best for: Jab humein sorted unique elements chahiye.

Example: TreeSet in Java

import java.util.TreeSet;
import java.util.Set;

public class TreeSetExample {
    public static void main(String[] args) {
        Set<String> names = new TreeSet<>();
        names.add("Zoya");
        names.add("Amit");
        names.add("Rahul");

        System.out.println(names);  // [Amit, Rahul, Zoya] (sorted)
    }
}

Output:

[Amit, Rahul, Zoya]

Internal Working of TreeSet

• Red-Black Tree (Self-balancing BST) use karta hai.
• Time Complexity:
• Insertion/Deletion/Search: O(log n)
• Sorting: Automatic (inorder traversal)

3. Queue Interface (PriorityQueue, Deque, ArrayDeque)

Queue ek FIFO (First-In-First-Out) structure hai, but PriorityQueue alag hai.

3.1 PriorityQueue – Min-Heap/Max-Heap Implementation

• Elements priority ke basis pe process hote hain.
• Default: Min-Heap (smallest element first).
• Best for: Jab humein priority-based processing chahiye.

Example: PriorityQueue in Java

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        Queue<Integer> pq = new PriorityQueue<>();
        pq.add(30);
        pq.add(10);
        pq.add(20);

        System.out.println(pq.poll());  // 10 (smallest removed first)
        System.out.println(pq.poll());  // 20
    }
}

Output:

10

20

Internal Working of PriorityQueue

• Min-Heap (Complete Binary Tree) use karta hai.
• Parent <= Children (for Min-Heap)
• Time Complexity:
• Insertion: O(log n)
• Poll/Remove: O(log n)

3.2 Deque (Double-Ended Queue) & ArrayDeque

• Insert/Remove from both ends possible.
• Faster than Stack/LinkedList for stack/queue operations.
• Best for: Jab humein stack + queue dono ki functionality chahiye.

Example: ArrayDeque in Java

import java.util.ArrayDeque;
import java.util.Deque;

public class DequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();
        deque.addFirst("First");
        deque.addLast("Last");
        deque.offer("End");

        System.out.println(deque);  // [First, Last, End]
        System.out.println(deque.pollFirst());  // First (removed)
    }
}

Output:

[First, Last, End]

First

Internal Working of ArrayDeque

• Resizable circular array use karta hai.
• No capacity restrictions (dynamic resizing).

4. Map Interface (HashMap, LinkedHashMap, TreeMap, HashTable)

Map key-value pairs store karta hai.

4.1 HashMap – Unordered, Fast Lookup

• No order maintained.
• Allows one null key & multiple null values.
• Best for: General-purpose key-value storage.

Example: HashMap in Java

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> marks = new HashMap<>();
        marks.put("Rahul", 90);
        marks.put("Priya", 85);
        marks.put("Rahul", 95);  // Overrides previous value

        System.out.println(marks);  // {Rahul=95, Priya=85}
    }
}

Output:

{Rahul=95, Priya=85}

Internal Working of HashMap

• Uses Array + LinkedList/Tree (Java 8+).
• Default capacity: 16, Load Factor: 0.75
• Collision Resolution:
• Before Java 8: Chaining (LinkedList)
• After Java 8: If bucket size > 8, converts to Tree (O(log n))

4.2 LinkedHashMap – Insertion Order Maintained

• HashMap + LinkedList combination.
• Maintains insertion order.

Example: LinkedHashMap in Java

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new LinkedHashMap<>();
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);

        System.out.println(map);  // {One=1, Two=2, Three=3} (order maintained)
    }
}

Output:

{One=1, Two=2, Three=3}

Internal Working of LinkedHashMap

• Extends HashMap, maintains doubly-linked list for ordering.

4.3 TreeMap – Sorted Order (Red-Black Tree)

• Keys sorted order mein store hote hain.
• Uses Comparable or Comparator.

Example: TreeMap in Java

import java.util.TreeMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();
        map.put("Zebra", 100);
        map.put("Apple", 50);
        map.put("Banana", 75);

        System.out.println(map);  // {Apple=50, Banana=75, Zebra=100} (sorted)
    }
}

Output:

{Apple=50, Banana=75, Zebra=100}

Internal Working of TreeMap

• Red-Black Tree (Self-balancing BST).
• Time Complexity: O(log n) for all operations.

4.4 HashTable – Thread-Safe Legacy Class

• Synchronized (thread-safe), but slow.
• Does not allow  null keys/values.

Example: HashTable in Java

import java.util.Hashtable;
import java.util.Map;

public class HashTableExample {
    public static void main(String[] args) {
        Map<String, Integer> table = new Hashtable<>();
        table.put("A", 1);
        table.put("B", 2);

        System.out.println(table);  // {A=1, B=2}
    }
}

Output:

{A=1, B=2}

HashMap vs HashTable

1. Thread-Safety (Synchronization): HashMap thread-safe nahi hota, matlab agar multiple threads same object ko access karein to dikkat ho sakti hai. Lekin ye zyada fast hota hai single-threaded situations mein. Wahin Hashtable thread-safe hota hai kyunki uske saare methods synchronized hote hain, is wajah se ye thoda slow hota hai.
2. Null Keys and Values: HashMap mein ek null key aur multiple null values allowed hoti hain. Lekin Hashtable mein null key allowed nahi hoti, aur null values bhi accept nahi karta.
3. Legacy Status: HashMap Java Collections Framework ka hissa hai aur ye modern (newer) implementation hai. Hashtable ek legacy class hai, jo purane Java versions se aati hai, aur aaj ke time mein use karne ki recommendation nahi hoti jab tak specific synchronization ki zarurat na ho.

5. Iterators (Iterator, ListIterator, forEach)

Collections ko traverse karne ke liye iterators use hote hain.

5.1 Iterator – Forward Traversal Only

• hasNext() , next() , remove  methods.

Example: Iterator in Java

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

public class IteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());  // A, B, C
        }
    }
}

Output:

A

B

C

5.2 ListIterator – Forward + Backward Traversal

• hasPrevious , previous  methods.

Example: ListIterator in Java

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

public class ListIteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("X");
        list.add("Y");
        list.add("Z");

        ListIterator<String> li = list.listIterator();
        while (li.hasNext()) {
            System.out.println(li.next());  // X, Y, Z
        }
        while (li.hasPrevious()) {
            System.out.println(li.previous());  // Z, Y, X
        }
    }
}

Output:

X

Y

Z

Z

Y

X

5.3 forEach Loop – Simplified Traversal

• Java 8+ forEach method.

Example: forEach in Java

import java.util.List;
import java.util.Arrays;

public class ForEachExample {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3);
        nums.forEach(num -> System.out.println(num));  // 1, 2, 3
    }
}

Output:

1

2

3

6. Comparable vs Comparator

6.1 Comparable – Natural Ordering

• Single sorting logic (compareTo method).

Example: Comparable in Java

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


public class ComparableExample {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Rahul", 25));
        students.add(new Student("Priya", 20));


        Collections.sort(students);
        students.forEach(s -> System.out.println(s.name));  // Priya, Rahul
    }
}




class Student implements Comparable<Student> {
    String name;
    int age;


    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }


    @Override
    public int compareTo(Student other) {
        return this.age - other.age;  // Sort by age
    }
}

Output:

Priya

Rahul

6.2 Comparator – Custom Sorting

• Multiple sorting logics (compare() method).

Example: Comparator in Java

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




public class ComparatorExample {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Zoya", 22));
        students.add(new Student("Amit", 20));


        Collections.sort(students, new NameComparator());
        students.forEach(s -> System.out.println(s.name));  // Output: Amit, Zoya
    }
}


class Student {
    String name;
    int age;


    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}


class NameComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.name.compareTo(s2.name);  // Sort by name
    }
}

Output:

Amit

Zoya

7. Collections Utility Class

Ye class useful static methods provide karti hai for collections manipulation.

Examples:

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

public class CollectionsUtilityExample {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(5);
        nums.add(2);
        nums.add(8);

        Collections.sort(nums);  // [2, 5, 8]
        Collections.reverse(nums);  // [8, 5, 2]
        Collections.shuffle(nums);  // Random order

        System.out.println(Collections.max(nums));  // 8
        System.out.println(Collections.min(nums));  // 2
    }
}

Output:

8

2

Conclusion

Java Collections Framework bohot powerful hai aur har type ke data storage ke liye optimized solutions provide karta hai.

• List → Duplicates allowed, ordered.
• Set → Unique elements.
• Queue → FIFO processing.
• Map → Key-value pairs.

Comparable vs Comparator, Iterators, aur Collections Utility Class ko samajh kar aap collections ko efficiently use kar sakte ho!