What is the Java Collections Framework?

The Java Collections Framework is a unified architecture for storing and manipulating groups of objects using interfaces like List, Set, and Map and implementing classes such as ArrayList, LinkedList, HashMap, and HashSet.

When should I use an ArrayList?

An ArrayList is ideal when you need fast random access and when insertions or deletions occur mostly at the end of the list. It is backed by a dynamic array structure.

When should I use a LinkedList?

LinkedList is preferred when an application requires frequent insertions or deletions in the middle of a list, as these operations are more efficient than with an ArrayList.

What is the purpose of a HashMap?

A HashMap stores data in key-value pairs and provides constant-time performance for get and put operations under average conditions. Keys must be unique, but values can be duplicated.

What is a HashSet used for?

A HashSet is used when you need to store unique elements with no duplicates. It is backed by a hash table and offers constant-time performance for add, remove, and contains operations.

Java Collections Framework – List, Set, Map, Iterator with Examples

The Java Collections Framework provides ready-made data structures such as List, Set, and Map. These classes help you store, search, sort, iterate, and manipulate data efficiently.

1. ArrayList

ArrayList is a resizable array. It allows duplicate values, maintains insertion order, and provides fast access by index.

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> cars = new ArrayList<>();

        cars.add("Volvo");
        cars.add("BMW");
        cars.add("Tesla");

        System.out.println("Cars: " + cars);

        cars.remove(0); // Remove element at index 0

        System.out.println("After removal: " + cars);
    }
}

2. LinkedList

LinkedList is faster than ArrayList for adding/removing elements frequently. It supports operations like addFirst(), addLast(), removeFirst(), and getFirst().

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> cars = new LinkedList<>();

        cars.add("Honda");
        cars.add("Toyota");
        cars.addFirst("Audi");
        cars.addLast("Ford");

        System.out.println("Cars: " + cars);

        cars.removeFirst();
        System.out.println("After removing first: " + cars);
    }
}

3. HashMap

HashMap stores data in key–value pairs. Keys must be unique. Values can be duplicated. HashMap does NOT maintain order.

import java.util.HashMap;

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<String, String> capitalCities = new HashMap<>();

        capitalCities.put("India", "New Delhi");
        capitalCities.put("Japan", "Tokyo");
        capitalCities.put("USA", "Washington DC");

        System.out.println(capitalCities);

        System.out.println("Capital of Japan: " + capitalCities.get("Japan"));
    }
}

4. HashSet

HashSet stores only unique values. It does NOT maintain order and is extremely fast for search operations.

import java.util.HashSet;

public class HashSetDemo {
    public static void main(String[] args) {
        HashSet<String> names = new HashSet<>();

        names.add("Raju");
        names.add("Ravi");
        names.add("Raju"); // Duplicate - ignored

        System.out.println(names);
    }
}

5. Iterator

Iterator is used to loop through any collection, especially when you need safe element removal during iteration.

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

public class IteratorDemo {
    public static void main(String[] args) {
        ArrayList<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());
        }
    }
}

6. Java Collection Hierarchy

The Java Collections Framework follows a well-defined hierarchy of interfaces and classes. At the top is the Collection interface, which is extended by List and Set. The Map interface is separate and does not extend Collection.

List – Ordered collection, allows duplicates
Set – Unordered collection, no duplicates
Queue – Used for holding elements prior to processing
Map – Stores key-value pairs

Understanding this hierarchy helps developers choose the correct data structure for each use case.

7. When to Use Which Collection

Choosing the right collection improves performance, readability, and scalability.

Use ArrayList when fast read operations are required
Use LinkedList when frequent insertions or deletions occur
Use HashSet when uniqueness is mandatory
Use HashMap when fast key-based lookup is required

In real-world projects, improper collection choice can cause performance bottlenecks.

8. Sorting Collections in Java

Java provides the Collections utility class to sort lists easily. Sorting is commonly used in reports, dashboards, and search results.

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

public class SortListDemo {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(40);
        numbers.add(10);
        numbers.add(30);

        Collections.sort(numbers);
        System.out.println(numbers);
    }
}

9. Iterating Collections Efficiently

Apart from Iterator, Java supports enhanced for-loops and lambda-based iteration. These approaches make code cleaner and more readable.

import java.util.ArrayList;

public class ForEachDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Spring");
        list.add("Hibernate");

        for (String item : list) {
            System.out.println(item);
        }
    }
}

Enhanced loops should be preferred when no removal operation is required.

10. Real-World Applications of Collections

Storing user lists in web applications
Caching data for performance optimization
Managing configuration settings
Processing large datasets
Handling API request and response data

Almost every backend system heavily relies on collections for data manipulation.

11. Performance Considerations

Different collections have different time complexities. Understanding these helps in writing efficient applications.

ArrayList – Fast access, slower insertion
LinkedList – Fast insertion, slower access
HashMap – Fast lookup, no ordering
HashSet – Fast search, unique elements

12. Common Mistakes with Collections

Using ArrayList where Set is required
Ignoring thread-safety requirements
Using raw types instead of generics
Modifying collection during iteration improperly

Avoiding these mistakes leads to cleaner and safer code.

13. Frequently Asked Interview Questions

Difference between ArrayList and LinkedList?
Difference between HashMap and Hashtable?
Why Map does not extend Collection?
When should Iterator be used?

Java Collections