The robust Java Collections Framework (JCF) For efficient data processing, manipulation, and storage, API provides a variety of data structures. The three most commonly used JCF interfaces are List, Set, and Map. It is necessary to comprehend these fundamental collection types in order to write Java programs that are both scalable and efficient.
In this blog, we’ll explore:
- What Lists, Sets, and Maps are
- How they differ from each other
- Common implementations of each
- When to use which collection
Also learn more about:-What is an API?
1. Lists in Java
A list is an ordered collection in Java that allows duplicate elements. Lists maintain the insertion order while providing indexed access to elements.
Examples of List Implementations:
ArrayList: A resizable array implementation.
LinkedList: A double linked list implementation.
These days, it’s rare to find a synchronized ArrayList like Vector.
Example: Using ArrayList
import java.util.*;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
list.add("Banana"); // Duplicates are allowed
System.out.println("List: " + list);
}
}Output:
List: [Apple, Banana, Cherry, Banana]When to Use a List?
- When you need to maintain the order of elements.
- When duplicates are required.
- When you need fast access by index (ArrayList) or frequent insertions/removals (LinkedList).
2. Sets in Java
In Java, a set is a collection that, with the exception of some implementations, does not permit duplicate elements and does not ensure order.
Typical Set Implementations:
- HashSet: Hashing is used; no order is preserved.
- The LinkedHashSet preserves the order of insertion.
- TreeSet: Preserves the sorted order, or natural ordering.
Example: Using HashSet
import java.util.*;
public class SetExample {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Cherry");
set.add("Banana"); // Duplicate, will not be added
System.out.println("Set: " + set);
}
}Output (Order may vary):
Set: [Apple, Banana, Cherry]When to Use a Set?
- When you need unique elements only.
- When order is not important (HashSet) or ordering is required (TreeSet).
- When frequent lookups are needed (HashSet provides O(1) lookup time).
3. Maps in Java
In Java, a collection that holds key-value pairs is called a map. Values can be replicated, but each key needs to be distinct.
Typical Map Implementations:
- Unordered key-value storage is known as a hash map.
- The LinkedHashMap preserves the order of insertion.
- TreeMap: Sorts and stores keys.
Example: Using HashMap
import java.util.*;
public class MapExample {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>();
map.put(1, "Apple");
map.put(2, "Banana");
map.put(3, "Cherry");
map.put(2, "Mango"); // Overwrites previous value
System.out.println("Map: " + map);
}
}Output (Order may vary):
Map: {1=Apple, 2=Mango, 3=Cherry}When to Use a Map?
- when key-value pairs must be used to store data.
- when quick key-based retrieval is required (HashMap provides O(1) lookup time).
- when an ordered key traversal (LinkedHashMap or TreeMap) is necessary.
Comparison Table: List vs Set vs Map
| Feature | List | Set | Map |
|---|---|---|---|
| Allows Duplicates | Yes | No | Keys: No, Values: Yes |
| Maintains Order | Yes (Insertion Order) | No (Except LinkedHashSet) | No (Except LinkedHashMap) |
| Access Time Complexity | O(1) (ArrayList), O(N) (LinkedList) | O(1) (HashSet), O(log N) (TreeSet) | O(1) (HashMap), O(log N) (TreeMap) |
| Key-Value Pairs | No | No | Yes |
Conclusion
In Java development, choosing the appropriate data structure requires an understanding of the distinctions between List, Set, and Map. Each has specific applications:
Use lists when it’s important to maintain organization and allow for duplicates.
Use Set when you need distinct elements.
Use Maps when it’s necessary to store key-value pairs.
Learning to use these collections can help you build more scalable and effective Java applications.
It might be helpful:
Is SAP ABAP a High Paying Job?
Your Definitive Guide to Becoming a SAP ABAP Developer
Is Java or Python Better for Full-Stack Development?
WhatsApp us