In this first part of the series on the Java Collections Framework, we’ll cover the foundational components—Lists, Sets, Maps—and the essential Collections Utility Class. By the end of this post, you’ll have a solid understanding of how these collections work and how to manipulate them effectively.
—
Table of Contents
- Introduction to the Collections Framework
-
Lists
- Overview
- Common Implementations
- Code Examples
- Common Pitfalls
-
Sets
- Overview
- Common Implementations
- Code Examples
- Common Pitfalls
-
Maps
- Overview
- Common Implementations
- Code Examples
- Common Pitfalls
-
Collections Utility Class
- Sorting Algorithms
- Min and Max Operations
- Code Examples
- Comparisons and Clarifications
- Challenges
- Conclusion
—
Introduction to the Collections Framework
The Java Collections Framework is essential for grouping, storing, and manipulating objects. It includes interfaces such as List, Set, and Map, and offers efficient algorithms and utility functions via the Collections
class.
- List: An ordered collection that allows duplicates.
- Set: A collection that does not allow duplicates.
- Map: Maps unique keys to values.
Understanding these structures is critical for efficient data handling in Java.
—
Lists
Overview
A List in Java is an ordered collection that allows duplicate elements. It provides precise control over where elements are inserted and accessed by their integer index.
Common Implementations
- ArrayList: Fast for random access, slower for insertion/removal in the middle.
- LinkedList: Faster for insertions and removals, slower for random access.
Code Examples
ArrayList Example:
import java.util.ArrayList;
import java.util.List;
public class ArrayListExample {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
fruits.add("Apple"); // Duplicate allowed
System.out.println("ArrayList: " + fruits);
}
}
LinkedList Example:
import java.util.LinkedList;
import java.util.List;
public class LinkedListExample {
public static void main(String[] args) {
List<String> animals = new LinkedList<>();
animals.add("Dog");
animals.add("Cat");
animals.add("Elephant");
System.out.println("LinkedList: " + animals);
}
}
Common Pitfalls
- Using
ArrayList
when frequent insertions/removals are required can cause performance issues. PreferLinkedList
in such cases. - Lists are not thread-safe by default. If you need a thread-safe list, use
Collections.synchronizedList()
.
—
Sets
Overview
A Set is a collection that does not allow duplicate elements, offering a powerful tool for when uniqueness is required.
Common Implementations
-
HashSet: Unordered and fast, allows one
null
element. - LinkedHashSet: Maintains insertion order.
- TreeSet: Sorted, based on natural ordering or a custom comparator.
Code Examples
HashSet Example:
import java.util.HashSet;
import java.util.Set;
public class HashSetExample {
public static void main(String[] args) {
Set<Integer> numbers = new HashSet<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
numbers.add(20); // Duplicate ignored
System.out.println("HashSet: " + numbers);
}
}
TreeSet Example:
import java.util.Set;
import java.util.TreeSet;
public class TreeSetExample {
public static void main(String[] args) {
Set<String> names = new TreeSet<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");
System.out.println("TreeSet (sorted): " + names);
}
}
Common Pitfalls
-
HashSet does not guarantee order. If you need to maintain order, use
LinkedHashSet
. - Avoid using mutable objects as
Set
elements, as changes in their state could affect theirhashCode()
orcompareTo()
behavior.
—
Maps
Overview
A Map is a collection of key-value pairs. Each key maps to exactly one value, and keys must be unique.
Common Implementations
-
HashMap: Fast, unordered, allows
null
keys and values. - LinkedHashMap: Maintains insertion order.
- TreeMap: Sorted according to the natural order of keys or a custom comparator.
Code Examples
HashMap Example:
import java.util.HashMap;
import java.util.Map;
public class HashMapExample {
public static void main(String[] args) {
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);
ages.put("Bob", 25);
ages.put("Charlie", 35);
ages.put("Alice", 32); // Overwrites previous value
System.out.println("HashMap: " + ages);
}
}
TreeMap Example:
import java.util.Map;
import java.util.TreeMap;
public class TreeMapExample {
public static void main(String[] args) {
Map<String, Double> productPrices = new TreeMap<>();
productPrices.put("Laptop", 999.99);
productPrices.put("Smartphone", 499.99);
productPrices.put("Tablet", 299.99);
System.out.println("TreeMap (sorted): " + productPrices);
}
}
Common Pitfalls
-
TreeMap
does not allownull
keys, whereasHashMap
does. - Inserting a duplicate key in a
Map
will overwrite the existing value, so be careful to check for existing keys if needed.
—
Collections Utility Class
The Collections
utility class provides static methods to manipulate or create collections. It includes methods for sorting, searching, and modifying collections.
Sorting Algorithms
You can sort a List
using the Collections.sort()
method.
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SortingExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");
// Natural order
Collections.sort(names);
System.out.println("Sorted: " + names);
// Reverse order
Collections.sort(names, Collections.reverseOrder());
System.out.println("Sorted in reverse: " + names);
}
}
Min and Max Operations
Finding the minimum and maximum element in a collection is straightforward with Collections.min()
and Collections.max()
.
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MinMaxExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(5);
numbers.add(30);
int min = Collections.min(numbers);
int max = Collections.max(numbers);
System.out.println("Min: " + min);
System.out.println("Max: " + max);
}
}
—
Comparisons and Clarifications
Lists vs. Sets
- Lists allow duplicates, while Sets do not.
- Lists maintain the order of elements, while HashSet (a type of set) does not guarantee any order.
Maps vs. Lists
- Maps store key-value pairs, whereas Lists store single elements in a sequence.
- Use a Map when you need to associate data (like a name and age), and use a List when you’re working with an ordered sequence of elements.
ArrayList vs. LinkedList
- ArrayList offers faster random access, but slower insertions/removals in the middle.
- LinkedList is more efficient for frequent insertions/removals, especially in the middle of the list.
—
Challenges
Challenge 1: Implement a To-Do List
Create a simple to-do list using an ArrayList
that:
- Adds tasks.
- Removes tasks by name.
- Prevents duplicate tasks.
Challenge 2: Unique Usernames
Use a HashSet
to store a list of unique usernames. Ensure duplicate entries are ignored.
Challenge 3: Phone Book
Create a phone book using a HashMap
to store names as keys and phone numbers as values. Ensure it supports adding and retrieving contacts efficiently.
—
Conclusion
In this post, we covered the essential components of the Java Collections Framework—Lists, Sets, Maps, and the Collections Utility Class. Understanding when and how to use these collections is key to writing efficient Java code. In the next post, we’ll dive deep into Generics in Collections to understand how to leverage type safety and improve code reusability.
—
Top comments (1)
interesting read, tried stuff out here github.com/mherman22/OneStopCentre.
Looking forward to part two