1
import java.util.ArrayList;
2
import java.util.List;
3

4
// 创建
5
List<String> list = new ArrayList<>();          // 空列表
6
List<String> withInit = new ArrayList<>(List.of("a", "b", "c"));
7
List<String> immutable = List.of("a", "b", "c"); // JDK 9+，不可变
8

9
// 添加
10
list.add("apple");                  // 尾部添加
11
list.add(0, "banana");              // 指定位置插入
12
list.addAll(List.of("x", "y"));     // 批量添加
13

14
// 访问
15
list.get(0);                        // "banana"
16
list.set(0, "cherry");              // 修改索引 0
17
list.indexOf("apple");              // 查找位置
18
list.contains("apple");             // 是否包含
19
list.size();                        // 长度
20
list.isEmpty();                     // 是否为空
21

22
// 删除
23
list.remove(0);                     // 按索引删
24
list.remove("apple");               // 按内容删（第一个匹配）
25
list.removeAll(List.of("x", "y"));  // 批量删
26
list.clear();                       // 清空
27

28
// 遍历
29
for (String s : list) System.out.println(s);
30
list.forEach(s -> System.out.println(s));
31
for (int i = 0; i < list.size(); i++) {
32
    System.out.println(list.get(i));
33
}

1
List<String> linked = new LinkedList<>();
2
linked.addFirst("a");     // LinkedList 特有
3
linked.addLast("z");
4
linked.removeFirst();
5
linked.removeLast();

1
import java.util.HashSet;
2
import java.util.Set;
3

4
Set<String> set = new HashSet<>();
5
set.add("apple");
6
set.add("banana");
7
set.add("apple");              // 已存在，不添加，add 返回 false
8

9
set.size();                    // 2
10
set.contains("apple");         // true
11
set.remove("apple");
12

13
// 遍历（顺序不保证）
14
for (String s : set) System.out.println(s);
15
set.forEach(System.out::println);

1
public class User {
2
    private String name;
3
    // 不重写 equals/hashCode 的话
4
}
5

6
Set<User> users = new HashSet<>();
7
users.add(new User("Tom"));
8
users.add(new User("Tom"));   // 变成 2 个元素！
9

10
// 重写了 equals/hashCode 后
11
users.add(new User("Tom"));
12
users.add(new User("Tom"));   // 只有 1 个 ✅

1
Set<String> set = new LinkedHashSet<>();
2
set.add("c");
3
set.add("a");
4
set.add("b");
5
// 遍历顺序：c, a, b（跟插入一致）

1
Set<Integer> nums = new TreeSet<>(List.of(5, 2, 8, 1, 9));
2
// 遍历顺序：1, 2, 5, 8, 9
3

4
Set<String> reverseOrder = new TreeSet<>(Comparator.reverseOrder());
5
reverseOrder.add("b");
6
reverseOrder.add("a");
7
reverseOrder.add("c");
8
// 遍历顺序：c, b, a

1
TreeSet<Integer> set = new TreeSet<>(List.of(1, 3, 5, 7, 9));
2
set.first();             // 1
3
set.last();              // 9
4
set.floor(6);            // 5，小于等于 6 的最大值
5
set.ceiling(6);          // 7，大于等于 6 的最小值
6
set.higher(5);           // 7，严格大于
7
set.lower(5);            // 3，严格小于
8
set.headSet(5);          // [1, 3]，小于 5 的子集
9
set.tailSet(5);          // [5, 7, 9]，大于等于 5 的子集

1
import java.util.ArrayDeque;
2
import java.util.Deque;
3

4
// 当队列用（FIFO）
5
Deque<String> queue = new ArrayDeque<>();
6
queue.offer("a");           // 尾部入队
7
queue.offer("b");
8
queue.poll();               // "a"，头部出队
9
queue.peek();               // "b"，查看头部但不删
10

11
// 当栈用（LIFO）
12
Deque<String> stack = new ArrayDeque<>();
13
stack.push("a");            // 头部入栈
14
stack.push("b");
15
stack.pop();                // "b"，头部出栈
16
stack.peek();               // "a"

1
import java.util.PriorityQueue;
2

3
PriorityQueue<Integer> pq = new PriorityQueue<>();   // 小顶堆
4
pq.offer(5);
5
pq.offer(1);
6
pq.offer(3);
7
pq.poll();     // 1（最小）
8
pq.poll();     // 3
9
pq.poll();     // 5
10

11
// 大顶堆
12
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());

1
import java.util.HashMap;
2
import java.util.Map;
3

4
// 创建
5
Map<String, Integer> map = new HashMap<>();
6
Map<String, Integer> withInit = Map.of("a", 1, "b", 2);   // 不可变，JDK 9+
7

8
// 增/改
9
map.put("apple", 3);
10
map.put("banana", 5);
11
map.put("apple", 10);              // 覆盖旧值
12

13
// 查
14
map.get("apple");                  // 10
15
map.getOrDefault("cherry", 0);     // 0（key 不存在时返回默认值）
16
map.containsKey("apple");          // true
17
map.containsValue(10);             // true
18
map.size();
19

20
// 删
21
map.remove("apple");
22
map.remove("apple", 10);           // 值匹配才删（更安全）
23
map.clear();
24

25
// 遍历
26
for (Map.Entry<String, Integer> e : map.entrySet()) {
27
    System.out.println(e.getKey() + " = " + e.getValue());
28
}
29

30
map.forEach((k, v) -> System.out.println(k + " = " + v));
31

32
// 只遍历 key 或 value
33
for (String k : map.keySet()) { ... }
34
for (Integer v : map.values()) { ... }

1
// putIfAbsent：不存在才放
2
map.putIfAbsent("cherry", 1);      // 如果 cherry 已存在则不改
3

4
// computeIfAbsent：不存在才计算并放（常用于分组）
5
Map<String, List<Integer>> grouped = new HashMap<>();
6
grouped.computeIfAbsent("odd", k -> new ArrayList<>()).add(1);
7
grouped.computeIfAbsent("odd", k -> new ArrayList<>()).add(3);
8
// {"odd": [1, 3]}
9

10
// compute：无论如何都重新计算
11
map.compute("apple", (k, v) -> v == null ? 1 : v + 1);
12

13
// merge：合并值（常用于计数）
14
Map<String, Integer> count = new HashMap<>();
15
for (String word : words) {
16
    count.merge(word, 1, Integer::sum);   // 计数经典写法
17
}

1
// 插入顺序
2
Map<String, Integer> insertion = new LinkedHashMap<>();
3
insertion.put("c", 3);
4
insertion.put("a", 1);
5
insertion.put("b", 2);
6
// 遍历：c, a, b
7

8
// 访问顺序（true 参数）：每次访问会把 key 移到末尾
9
Map<String, Integer> access = new LinkedHashMap<>(16, 0.75f, true);

1
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
2
    private final int capacity;
3

4
    public LRUCache(int capacity) {
5
        super(capacity, 0.75f, true);
6
        this.capacity = capacity;
7
    }
8

9
    @Override
10
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
11
        return size() > capacity;
12
    }
13
}

1
Map<String, Integer> sorted = new TreeMap<>();
2
sorted.put("banana", 2);
3
sorted.put("apple", 1);
4
sorted.put("cherry", 3);
5
// 遍历顺序：apple, banana, cherry（字典序）
6

7
// 范围查询
8
sorted.headMap("banana");       // {apple=1}
9
sorted.tailMap("banana");       // {banana=2, cherry=3}
10
sorted.subMap("a", "c");        // 左闭右开
11
sorted.firstKey();
12
sorted.lastKey();

1
HashMap 内部是一个 Node<K,V>[] table 数组（叫"桶"）
2
每个 Node 有 hash、key、value、next 四个字段
3

4
put(k, v) 流程：
5
1. 算 hash：h = k.hashCode() ^ (h >>> 16)   ← 扰动函数，减少冲突
6
2. 定位桶：index = (n - 1) & hash          ← n 是数组长度（2 的幂）
7
3. 桶为空 → 直接放
8
4. 桶非空 → 遍历链表/红黑树找同 key（equals）→ 覆盖或追加
9
5. 超过阈值 → 扩容 2 倍，重新分布元素

1
Iterator<String> it = list.iterator();
2
while (it.hasNext()) {
3
    String s = it.next();
4
    if (s.startsWith("a")) {
5
        it.remove();          // ✅ 唯一安全的遍历时删除方式
6
    }
7
}

1
List<String> list = new ArrayList<>(List.of("a", "b", "c"));
2

3
// ❌ 抛异常
4
for (String s : list) {
5
    if (s.equals("a")) list.remove(s);
6
}
7

8
// ❌ 抛异常
9
list.forEach(s -> {
10
    if (s.equals("a")) list.remove(s);
11
});
12

13
// ✅ 用 Iterator.remove
14
Iterator<String> it = list.iterator();
15
while (it.hasNext()) {
16
    if (it.next().equals("a")) it.remove();
17
}
18

19
// ✅ 用 removeIf（JDK 8+，最简洁）
20
list.removeIf(s -> s.equals("a"));
21

22
// ✅ 用 Stream 过滤生成新列表
23
List<String> filtered = list.stream().filter(s -> !s.equals("a")).toList();