Slight Insight

Java Collections Framework is a powerful set of interfaces and classes that provide efficient ways to store, retrieve, and manipulate data. Understanding the nuances of different collection types is crucial for writing optimized and performant Java applications. In this article, we’ll explore the core Java collections, their usage, performance characteristics, and common use cases.

Overview of Java Collections

Java collections are broadly classified into three categories:

1. List – Ordered collection of elements.
2. Set – Unordered collection of unique elements.
3. Queue – FIFO (First-In-First-Out) principle.
4. Map – Key-value pairs.

Using Java Collections

List

A List maintains the insertion order and allows duplicate elements.

Common Implementations

• ArrayList: Backed by a dynamic array, good for random access.
• LinkedList: Doubly linked list, better for frequent insertions/deletions.
• Vector: Synchronized version of ArrayList.

import java.util.*;

public class ListExample {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Apple"); // Allows duplicates

        System.out.println("ArrayList: " + arrayList);

        List<String> fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add(1, "Mango"); // Add "Mango" at index 1
    }
}

Set

A Set ensures no duplicate elements.

Common Implementations

• HashSet: Uses hash table, no guaranteed order. HashSet provides fast lookups and is suitable when you need to ensure uniqueness of elements.
• LinkedHashSet: LinkedHashSet maintains insertion order while ensuring uniqueness. LinkedHashSet is useful when you need both uniqueness and predictable iteration order.
• TreeSet: Sorted in natural order.

import java.util.*;

public class SetExample {
    public static void main(String[] args) {

        Set<String> fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        boolean contains = fruits.contains("Apple"); // Check if "Apple" is present        

        Set<String> treeSet = new TreeSet<>();
        treeSet.add("Dog");
        treeSet.add("Cat");
        treeSet.add("Dog"); // Ignored

        System.out.println("TreeSet: " + treeSet);
    }
}

Queue

A Queue is used for FIFO (First-In-First-Out) order.

Common Implementations

• PriorityQueue: Elements are ordered by priority. PriorityQueue is useful for implementing priority-based tasks.
• ArrayDeque: Double-ended queue that allows adding and removing elements from both ends. ArrayDeque is efficient for implementing queues and stacks.

import java.util.*;

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

        System.out.println("PriorityQueue: " + priorityQueue);
    }
}

Map

A Map stores key-value pairs.

Common Implementations

• HashMap: Unordered, fast lookup.
• LinkedHashMap: Maintains insertion order.
• TreeMap: Sorted by keys.

import java.util.*;

public class MapExample {
    public static void main(String[] args) {
        Map<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1, "One");
        hashMap.put(2, "Two");
        hashMap.put(1, "Uno"); // Overwrites key 1

        System.out.println("HashMap: " + hashMap);
    }
}

When to Use Which Collection?

Scenario	Recommended Collection
Fast random access	ArrayList
Frequent insertions/deletions	LinkedList
Unique elements without order	HashSet
Unique elements with insertion order	LinkedHashSet
Unique elements sorted	TreeSet
Key-value pairs without order	HashMap
Key-value pairs with insertion order	LinkedHashMap
Key-value pairs sorted by keys	TreeMap
Priority-based processing	PriorityQueue

Performance Comparison

Collection	Time Complexity (Insert)	Time Complexity (Search)	Ordered	Thread-Safe
ArrayList	O(1)	O(1)	Yes	No
LinkedList	O(1) (at ends)	O(n)	Yes	No
HashSet	O(1)	O(1)	No	No
TreeSet	O(log n)	O(log n)	Yes	No
HashMap	O(1)	O(1)	No	No
TreeMap	O(log n)	O(log n)	Yes	No
PriorityQueue	O(log n)	O(1) (peek)	No	No

Conclusion

The Java Collections Framework offers a rich set of tools for managing data efficiently. By understanding the characteristics of different collection types, you can choose the most appropriate one for your specific needs and write high-performance Java applications.

Frequently Asked Questions