Abhishek Kumar

Posted on Oct 3, 2024

Differences between Set and List in Java

Both Set and List are part of the Java Collections Framework and are used to store collections of elements. However, they have distinct characteristics and are suited to different use cases.

Feature	List	Set
Ordering	Preserves the order of insertion.	No guarantee of order (except in `LinkedHashSet`).
Duplicates	Allows duplicates.	Does not allow duplicates.
Null Values	Can have multiple `null` values (depending on the implementation).	Can have only one `null` value (depends on implementation, e.g., `HashSet` allows one `null`).
Implementation Classes	`ArrayList`, `LinkedList`, `Vector`, etc.	`HashSet`, `LinkedHashSet`, `TreeSet`, etc.
Random Access	Provides random access via index (e.g., `get(index)`).	Does not support random access via index.
Common Operations	Supports positional access (e.g., `get`, `set`, `add` at a specific index).	No positional access. Focuses on checking membership (e.g., `contains`).
Performance (Access)	Fast random access in `ArrayList` (O(1)), slower in `LinkedList` (O(n)).	Access operations like `contains()` in `HashSet` are O(1) on average. `TreeSet` operations are O(log n).
Performance (Insertion/Removal)	Insertion/removal in `ArrayList` may be O(n) due to shifting, O(1) at end. `LinkedList` has O(1) insertion/removal at head/tail.	Insertion/removal in `HashSet` is O(1) on average; in `TreeSet`, it is O(log n).
Best Use Case	When you need to maintain the insertion order and/or allow duplicates.	When you need to eliminate duplicates and order does not matter.

Detailed Comparison:

1. Duplicates

List: Allows multiple occurrences of the same element.

Example:

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Apple");  // Both entries are allowed

Set: Does not allow duplicates. If you try to add a duplicate, it will ignore the new element.

Example:

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Apple");  // The second entry is ignored

2. Order

List: Maintains the order of insertion, so elements are retrieved in the order they were added.

Example:

List<String> list = new ArrayList<>();
list.add("Banana");
list.add("Apple");
list.add("Orange");
System.out.println(list);  // Output: [Banana, Apple, Orange]

Set: Does not maintain any specific order (though LinkedHashSet preserves insertion order, and TreeSet orders elements based on their natural order or a comparator).

Example:

Set<String> set = new HashSet<>();
set.add("Banana");
set.add("Apple");
set.add("Orange");
System.out.println(set);  // Output may vary: [Apple, Orange, Banana]

3. Null Handling

List: Can store multiple null elements (depending on the implementation).

Example:

List<String> list = new ArrayList<>();
list.add(null);
list.add(null);  // Multiple nulls allowed

Set: Can store at most one null element (in HashSet and LinkedHashSet). TreeSet does not allow null.

Example:

Set<String> set = new HashSet<>();
set.add(null);
set.add(null);  // Only one null is allowed

4. Access by Index

List: Supports access by index, meaning you can retrieve, modify, or remove elements based on their position in the list. This allows random access and positional manipulation.
- Example:
```
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
System.out.println(list.get(1));  // Output: Banana
```
Set: Does not support access by index. You must iterate through the set to retrieve elements. You cannot directly access elements by their position.
- Example:
```
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
// No direct way to get the element at index 1
```

5. Performance

List:
- Accessing elements by index is O(1) in ArrayList, but O(n) in LinkedList.
- Insertion/removal at the end of the ArrayList is O(1), but it is O(n) in the middle (due to shifting). LinkedList has O(1) insertions at both ends but O(n) in the middle.
Set:
- HashSet: Provides O(1) time complexity for add, remove, and contains operations (on average), but order is not maintained.
- TreeSet: Operations like add, remove, and contains are O(log n) since it is backed by a balanced binary tree, but it sorts the elements.

6. Use Cases

List:
- Best for when you need ordered collections, allow duplicates, and need random access to elements.
- Use ArrayList for efficient random access and LinkedList for efficient insertions/deletions at both ends.
Set:
- Best for when you need to eliminate duplicates and don't care about element order (unless you use LinkedHashSet or TreeSet).
- Use HashSet for general-purpose collections with fast performance. Use TreeSet if you need the elements to be sorted.

Example Code:

import java.util.*;

public class ListSetExample {
    public static void main(String[] args) {
        // List Example
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Apple");  // Duplicates allowed
        System.out.println("List: " + list);  // Output: [Apple, Banana, Apple]

        // Set Example
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Apple");  // Duplicate ignored
        System.out.println("Set: " + set);  // Output: [Banana, Apple] or any order
    }
}

Conclusion:

List: Allows duplicates, maintains insertion order, and provides random access via index. Ideal for ordered data and when duplicates are needed.
Set: No duplicates, no guaranteed order (unless using LinkedHashSet or TreeSet). Ideal when you need to ensure uniqueness in a collection of elements.

DEV Community