Lists, Sets, and Maps in Java Collections

In Java, the Collections Framework provides a powerful and flexible set of interfaces and classes that allow developers to work with various data structures like Lists, Sets, and Maps. These are three core collection types that serve different purposes depending on the requirements of your application. Each collection type has specific characteristics and behaviors that make it suitable for certain types of data storage and manipulation.

1. Lists in Java Collections

A List is an ordered collection that allows duplicate elements. Lists can maintain the order of insertion, which means the elements will appear in the same sequence as they were added.

Key Characteristics of Lists:

Ordered: Elements are stored in the order they are added.
Allows Duplicates: A List can contain duplicate elements.
Indexed Access: Lists allow accessing elements by their index, meaning you can retrieve an element at a specific position in the list.

Common List Implementations:

ArrayList: A resizable array implementation. It allows fast random access to elements and is preferred when you need efficient access to elements by index.
LinkedList: A doubly linked list implementation. It is more efficient than ArrayList for inserting or removing elements from the beginning or middle of the list.
Vector: Similar to ArrayList, but synchronized for thread safety. It’s generally considered obsolete and is rarely used in modern Java.

Example:

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("Apple");  // Duplicates allowed
        
        System.out.println(list);  // Output: [Apple, Banana, Apple]
        System.out.println(list.get(1));  // Output: Banana
    }
}

Common List Methods:

add(E element): Adds an element to the list.
get(int index): Retrieves the element at the specified index.
remove(int index): Removes the element at the specified index.
size(): Returns the number of elements in the list.

2. Sets in Java Collections

A Set is an unordered collection that does not allow duplicate elements. Sets are used when you need to ensure that each element is unique.

Key Characteristics of Sets:

Unordered: Sets do not guarantee any specific order of elements.
No Duplicates: A Set does not allow duplicate elements. If you try to add a duplicate, it will simply ignore the new element.
Efficient Lookups: Sets are optimized for checking membership and eliminating duplicates.

Common Set Implementations:

HashSet: The most commonly used implementation. It does not maintain any order of the elements and provides constant-time performance for basic operations like add, remove, and contains.
LinkedHashSet: Maintains the insertion order of elements, so elements are iterated in the order they were added.
TreeSet: A sorted set that maintains elements in a sorted order (either by their natural ordering or a comparator).

Example:

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("Apple");  // Duplicate will be ignored
        
        System.out.println(set);  // Output: [Apple, Banana] (order is not guaranteed)
    }
}

Common Set Methods:

add(E element): Adds an element to the set (returns false if the element already exists).
remove(Object o): Removes an element from the set.
contains(Object o): Checks if the set contains the specified element.
size(): Returns the number of elements in the set.

3. Maps in Java Collections

A Map is an object that maps keys to values, where each key is unique and maps to exactly one value. It is not a true collection in the sense that it doesn’t implement the Collection interface, but it is a part of the Collections Framework.

Key Characteristics of Maps:

Key-Value Pair: A Map stores data as key-value pairs. Each key is unique, and each key maps to exactly one value.
No Duplicate Keys: A Map does not allow duplicate keys. However, values can be duplicated.
Efficient Retrieval: Maps are designed for efficient lookups, insertions, and deletions based on keys.

Common Map Implementations:

HashMap: The most commonly used map implementation. It does not guarantee any specific order of elements. It allows null for both keys and values.
LinkedHashMap: Similar to HashMap, but maintains the insertion order of keys.
TreeMap: A sorted map that maintains keys in sorted order, either by their natural ordering or according to a comparator.

Example:

import java.util.*;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 3);
        map.put("Banana", 5);
        map.put("Apple", 4);  // Value associated with "Apple" is updated
        
        System.out.println(map);  // Output: {Apple=4, Banana=5}
        System.out.println(map.get("Apple"));  // Output: 4
    }
}

Common Map Methods:

put(K key, V value): Adds a key-value pair to the map.
get(Object key): Retrieves the value associated with the specified key.
remove(Object key): Removes the key-value pair with the specified key.
containsKey(Object key): Checks if the map contains the specified key.
keySet(): Returns a set view of the keys contained in the map.
values(): Returns a collection view of the values contained in the map.

4. Comparison of Lists, Sets, and Maps

Feature	List	Set	Map
Duplicates	Allows duplicates	Does not allow duplicates	Allows duplicate values but not duplicate keys
Order	Maintains insertion order (or index order)	No specific order (unless `LinkedHashSet` or `TreeSet`)	Does not guarantee order (unless `LinkedHashMap` or `TreeMap`)
Access	Random access via index	No index-based access	Access via keys (not indexes)
Use Case	When order matters or you need indexed access	When uniqueness of elements is required	When you need to map unique keys to values