Collections Framework in Java

The Java Collections Framework (JCF) is a powerful set of interfaces and classes for storing groups of objects. From dynamic lists to fast lookups and ordered maps, the JCF gives you ready-made data structures so you can focus on business logic instead of writing arrays and trees by hand.

• Import: import java.util.*;
• Create list: List<Integer> list = new ArrayList<>();
• Create set: Set<String> set = new HashSet<>();
• Create map: Map<String,Integer> map = new HashMap<>();

Let's start with a hands-on example. The program below shows the core idea behind Collections in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

import java.util.*;

class Main
{
    public static void main(String args[])
    {
        List list = new ArrayList<>();

        list.add("Java");
        list.add("Python");
        list.add("Java");

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

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

import java.util.*;

class Main
{
    public static void main(String args[])
    {
        Set set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(10);  // duplicate ignored

        System.out.println(set);
    }
}

import java.util.*;

class Main
{
    public static void main(String args[])
    {
        Map ages = new HashMap<>();
        ages.put("Aman", 22);
        ages.put("Riya", 25);

        for (Map.Entry e : ages.entrySet())
            System.out.println(e.getKey() + " = " + e.getValue());
    }
}

import java.util.*;

class Main
{
    public static void main(String args[])
    {
        List list = new ArrayList<>(Arrays.asList(5, 2, 9, 1, 4));

        Collections.sort(list);

        System.out.println(list);
    }
}

import java.util.*;

class Main
{
    public static void main(String args[])
    {
        TreeSet ts = new TreeSet<>();
        ts.add(40); ts.add(10); ts.add(30); ts.add(20);

        System.out.println(ts);
    }
}

import java.util.*;

class Main
{
    public static void main(String args[])
    {
        List list = Arrays.asList("A", "B", "C");

        Iterator it = list.iterator();
        while (it.hasNext())
            System.out.println(it.next());
    }
}

• Use List for ordered data with duplicates.
• Use Set for unique elements.
• Use Map for key → value mapping.
• Always use generics (<T>) for type safety.
• Collections utility offers sort, reverse, shuffle, binarySearch.

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Remove duplicates from an ArrayList using HashSet.
• Q2. Count word frequency in a sentence using HashMap.
• Q3. Sort an ArrayList in descending order.
• Q4. Implement a stack using ArrayDeque.
• Q5. Iterate a HashMap using both entrySet() and keySet().

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with Collections in Java:

• Forgetting the semicolon ; at the end of statements while using Collections.
• Mixing up similar method names — read Java docs before using new APIs related to Collections.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.