Collections
## Learning Objectives
- Master List, Set, Map interfaces
- Understand collection hierarchy
- Choose appropriate collection types
- Work with iterators
## Collection Hierarchy
```text
Iterable
├── Collection
│ ├── List (ordered, duplicates)
│ │ ├── ArrayList
│ │ ├── LinkedList
│ │ └── Vector
│ ├── Set (unordered, no duplicates)
│ │ ├── HashSet
│ │ ├── LinkedHashSet
│ │ └── TreeSet
│ └── Queue (FIFO)
│ ├── LinkedList
│ ├── PriorityQueue
│ └── Deque
└── Map (key-value pairs)
├── HashMap
├── LinkedHashMap
├── TreeMap
└── Hashtable
```
## List Interface
### ArrayList (Most Common)
```java
import java.util.ArrayList;
ArrayList list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
// Access
System.out.println(list.get(0)); // Apple
System.out.println(list.size()); // 3
System.out.println(list.contains("Apple")); // true
// Modify
list.set(1, "Mango");
list.remove("Apple");
```
### LinkedList
```java
import java.util.LinkedList;
LinkedList list = new LinkedList<>();
list.add("First");
list.addFirst("BeforeFirst");
list.addLast("Last");
String first = list.getFirst();
String last = list.getLast();
list.removeFirst();
list.removeLast();
```
### Common List Methods
```java
list.add(element); // Append
list.add(index, element); // Insert at position
list.get(index); // Get element
list.set(index, element); // Replace
list.remove(index); // Remove by index
list.remove(Object); // Remove by value
list.size(); // Number of elements
list.contains(Object); // Contains element
list.indexOf(Object); // First occurrence
list.lastIndexOf(Object); // Last occurrence
list.clear(); // Remove all
```
## Set Interface
### HashSet (Most Common)
```java
import java.util.HashSet;
HashSet set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple"); // Duplicate - ignored
System.out.println(set.size()); // 2
System.out.println(set.contains("Apple")); // true
set.remove("Banana");
```
### LinkedHashSet
Preserves insertion order:
```java
LinkedHashSet set = new LinkedHashSet<>();
set.add("First");
set.add("Second");
set.add("Third");
// Iteration: First, Second, Third
```
### TreeSet
Sorted order:
```java
TreeSet set = new TreeSet<>();
set.add(3);
set.add(1);
set.add(2);
// Iteration: 1, 2, 3
// Methods
set.lower(2); // 1 (greatest < 2)
set.higher(2); // 3 (least > 2)
set.floor(2); // 2 (greatest <= 2)
set.ceiling(2); // 2 (least >= 2)
```
## Map Interface
### HashMap (Most Common)
```java
import java.util.HashMap;
HashMap map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 35);
System.out.println(map.get("Alice")); // 25
System.out.println(map.size()); // 3
System.out.println(map.containsKey("Bob")); // true
map.put("Alice", 26); // Update value
map.remove("Charlie");
```
### TreeMap
Sorted by keys:
```java
TreeMap map = new TreeMap<>();
map.put("Charlie", 35);
map.put("Alice", 25);
map.put("Bob", 30);
// Iteration: Alice(25), Bob(30), Charlie(35)
```
### Map Methods
```java
map.put(key, value); // Add/update
map.get(key); // Get value
map.remove(key); // Remove
map.containsKey(key); // Key exists
map.containsValue(value); // Value exists
map.size(); // Number of entries
map.keySet(); // Set of keys
map.values(); // Collection of values
map.entrySet(); // Set of key-value pairs
map.getOrDefault(key, default); // Get or default
```
### Iterate Map
```java
// Keys
for (String key : map.keySet()) {
System.out.println(key);
}
// Values
for (Integer value : map.values()) {
System.out.println(value);
}
// Entries
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// Java 8+ forEach
map.forEach((key, value) -> {
System.out.println(key + ": " + value);
});
```
## Queue Interface
### LinkedList as Queue
```java
import java.util.LinkedList;
import java.util.Queue;
Queue queue = new LinkedList<>();
queue.offer("First");
queue.offer("Second");
queue.offer("Third");
System.out.println(queue.peek()); // First (view)
System.out.println(queue.poll()); // First (remove)
System.out.println(queue.size()); // 2
```
### PriorityQueue
```java
PriorityQueue pq = new PriorityQueue<>();
pq.offer(3);
pq.offer(1);
pq.offer(2);
System.out.println(pq.poll()); // 1 (smallest)
System.out.println(pq.poll()); // 2
System.out.println(pq.poll()); // 3
```
## Deque Interface
### Double-ended Queue
```java
import java.util.ArrayDeque;
ArrayDeque deque = new ArrayDeque<>();
deque.addFirst("First");
deque.addLast("Last");
System.out.println(deque.getFirst()); // First
System.out.println(deque.getLast()); // Last
deque.removeFirst();
deque.removeLast();
```
## Choosing Collection
| Need | Collection |
|------|-----------|
| Fast lookup by index | ArrayList |
| Add/remove from both ends | LinkedList |
| Unique elements, no order | HashSet |
| Unique elements, insertion order | LinkedHashSet |
| Unique elements, sorted | TreeSet |
| Key-value pairs | HashMap |
| Key-value pairs, sorted keys | TreeMap |
| FIFO queue | Queue / LinkedList |
| Priority processing | PriorityQueue |
| Stack (LIFO) | Deque / ArrayDeque |
## Arrays vs Collections
```java
// Arrays: fixed size, primitives OK
String[] array = new String[10];
array[0] = "Apple";
// Collections: dynamic size, objects only
ArrayList list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
```
## Converting
### Array to List
```java
String[] array = {"A", "B", "C"};
List list = Arrays.asList(array);
List list2 = new ArrayList<>(Arrays.asList(array));
```
### List to Array
```java
List list = new ArrayList<>();
list.add("A");
list.add("B");
String[] array = list.toArray(new String[0]);
```
## Summary
- **List**: Ordered, duplicates - ArrayList most common
- **Set**: Unordered, unique - HashSet most common
- **Map**: Key-value - HashMap most common
- **Queue**: FIFO - LinkedList or PriorityQueue
- **Deque**: Both ends - ArrayDeque
- Use generics: `ArrayList`, `HashMap`
- Choose based on: ordering, uniqueness, performance needs
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →